INSTRUCTION
stringlengths 202
35.5k
| RESPONSE
stringlengths 75
161k
|
|---|---|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
require 'rubygems/package'
module Packages
module Rubygems
class ProcessGemService
include Gitlab::Utils::StrongMemoize
include ExclusiveLeaseGuard
ExtractionError = Class.new(StandardError)
InvalidMetadataError = Class.new(StandardError)
DEFAULT_LEASE_TIMEOUT = 1.hour.to_i.freeze
def initialize(package_file)
@package_file = package_file
end
def execute
raise ExtractionError, 'Gem was not processed - package_file is not set' unless package_file
return success if process_gem
error('Gem was not processed')
rescue ActiveRecord::StatementInvalid
# TODO: We can remove this rescue block when we fix https://gitlab.com/gitlab-org/gitlab/-/issues/415899
raise InvalidMetadataError, 'Invalid metadata'
end
private
attr_reader :package_file
def process_gem
try_obtain_lease do
package.transaction do
rename_package_and_set_version
rename_package_file
::Packages::Rubygems::MetadataExtractionService.new(package, gemspec).execute
::Packages::Rubygems::CreateGemspecService.new(package, gemspec).execute
::Packages::Rubygems::CreateDependenciesService.new(package, gemspec).execute
cleanup_temp_package
end
end
true
end
def rename_package_and_set_version
package.update!(
name: gemspec.name,
version: gemspec.version,
status: :default
)
end
def rename_package_file
# Updating file_name updates the path where the file is stored.
# We must pass the file again so that CarrierWave can handle the update
package_file.update!(
file_name: "#{gemspec.name}-#{gemspec.version}.gem",
file: package_file.file,
package_id: package.id
)
end
def cleanup_temp_package
temp_package.destroy if package.id != temp_package.id
end
def gemspec
gem.spec
end
strong_memoize_attr :gemspec
def success
ServiceResponse.success(payload: { package: package })
end
def error(message)
ServiceResponse.error(message: message)
end
def temp_package
package_file.package
end
strong_memoize_attr :temp_package
def package
package = temp_package.project
.packages
.rubygems
.with_name(gemspec.name)
.with_version(gemspec.version.to_s)
.not_pending_destruction
.last
package || temp_package
end
strong_memoize_attr :package
def gem
# use_file will set an exclusive lease on the file for as long as
# the resulting gem object is being used. This means we are not
# able to rename the package_file while also using the gem object.
# We need to use a separate AR object to create the gem file to allow
# `package_file` to be free for update so we re-find the file here.
Packages::PackageFile.find(package_file.id).file.use_file do |file_path|
Gem::Package.new(File.open(file_path))
end
rescue StandardError
raise ExtractionError, 'Unable to read gem file'
end
# used by ExclusiveLeaseGuard
def lease_key
"packages:rubygems:process_gem_service:package:#{package.id}"
end
# used by ExclusiveLeaseGuard
def lease_timeout
DEFAULT_LEASE_TIMEOUT
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Rubygems::ProcessGemService, feature_category: :package_registry do
include ExclusiveLeaseHelpers
include RubygemsHelpers
let_it_be_with_reload(:package) { create(:rubygems_package, :processing, name: 'temp_name', version: '0.0.0') }
let(:package_file) { create(:package_file, :unprocessed_gem, package: package) }
let(:gem) { gem_from_file(package_file.file) }
let(:gemspec) { gem.spec }
let(:service) { described_class.new(package_file) }
describe '#execute' do
subject { service.execute }
context 'no gem file' do
let(:package_file) { nil }
it 'returns an error' do
expect { subject }.to raise_error(::Packages::Rubygems::ProcessGemService::ExtractionError, 'Gem was not processed - package_file is not set')
end
end
context 'success' do
let(:sub_service) { double }
before do
expect(Packages::Rubygems::MetadataExtractionService).to receive(:new).with(package, gemspec).and_return(sub_service)
expect(Packages::Rubygems::CreateGemspecService).to receive(:new).with(package, gemspec).and_return(sub_service)
expect(Packages::Rubygems::CreateDependenciesService).to receive(:new).with(package, gemspec).and_return(sub_service)
expect(sub_service).to receive(:execute).exactly(3).times.and_return(true)
end
it 'returns successfully', :aggregate_failures do
result = subject
expect(result.success?).to be true
expect(result.payload[:package]).to eq(package)
end
it 'updates the package name and version', :aggregate_failures do
expect(package.name).to eq('temp_name')
expect(package.version).to eq('0.0.0')
expect(package).to be_processing
subject
expect(package.reload.name).to eq('package')
expect(package.version).to eq('0.0.1')
expect(package).to be_default
end
it 'updates the package file name', :aggregate_failures do
expect(package_file.file_name).to eq('package.gem')
subject
expect(package_file.reload.file_name).to eq('package-0.0.1.gem')
end
end
context 'when the package already exists' do
let_it_be(:existing_package) { create(:rubygems_package, name: 'package', version: '0.0.1', project: package.project) }
let(:sub_service) { double }
before do
expect(Packages::Rubygems::MetadataExtractionService).to receive(:new).with(existing_package, gemspec).and_return(sub_service)
expect(Packages::Rubygems::CreateGemspecService).to receive(:new).with(existing_package, gemspec).and_return(sub_service)
expect(Packages::Rubygems::CreateDependenciesService).to receive(:new).with(existing_package, gemspec).and_return(sub_service)
expect(sub_service).to receive(:execute).exactly(3).times.and_return(true)
end
it 'assigns the package_file to the existing package and deletes the temporary package', :aggregate_failures do
expect(package).to receive(:destroy)
expect { subject }.to change { existing_package.package_files.count }.by(1)
expect(package_file.reload.package).to eq(existing_package)
end
end
context 'when the package already exists marked as pending_destruction' do
let_it_be_with_reload(:existing_package) { create(:rubygems_package, name: 'package', version: '0.0.1', project: package.project) }
let(:sub_service) { double }
before do
expect(Packages::Rubygems::MetadataExtractionService).to receive(:new).with(package, gemspec).and_return(sub_service)
expect(Packages::Rubygems::CreateGemspecService).to receive(:new).with(package, gemspec).and_return(sub_service)
expect(Packages::Rubygems::CreateDependenciesService).to receive(:new).with(package, gemspec).and_return(sub_service)
expect(sub_service).to receive(:execute).exactly(3).times.and_return(true)
existing_package.pending_destruction!
end
it 'reuses the processing package' do
expect { subject }
.to not_change { package.project.packages.count }
.and not_change { existing_package.package_files.count }
end
end
context 'sub-service failure' do
before do
expect(Packages::Rubygems::MetadataExtractionService).to receive(:new).with(package, gemspec).and_raise(::Packages::Rubygems::ProcessGemService::ExtractionError.new('failure'))
end
it 'returns an error' do
expect { subject }.to raise_error(::Packages::Rubygems::ProcessGemService::ExtractionError, 'failure')
end
end
context 'bad gem file' do
before do
expect(Gem::Package).to receive(:new).and_raise(ArgumentError)
end
it 'returns an error' do
expect { subject }.to raise_error(::Packages::Rubygems::ProcessGemService::ExtractionError, 'Unable to read gem file')
end
end
context 'without obtaining an exclusive lease' do
let(:lease_key) { "packages:rubygems:process_gem_service:package:#{package.id}" }
before do
stub_exclusive_lease_taken(lease_key, timeout: 1.hour)
end
it 'does not perform the services', :aggregate_failures do
# The #use_file call triggers a separate lease on the package file being opened
# for use with the gem. We don't want to test that here, so we allow the call to proceed
expect(Gitlab::ExclusiveLease).to receive(:new).with("object_storage_migrate:Packages::PackageFile:#{package_file.id}", anything).and_call_original
expect(Packages::Rubygems::MetadataExtractionService).not_to receive(:new)
expect(Packages::Rubygems::CreateGemspecService).not_to receive(:new)
expect(Packages::Rubygems::CreateDependenciesService).not_to receive(:new)
subject
expect(package.reload.name).to eq('temp_name')
expect(package.version).to eq('0.0.0')
expect(package).to be_processing
expect(package_file.reload.file_name).to eq('package.gem')
end
end
context 'with invalid metadata' do
include_context 'with invalid Rubygems metadata'
it 'raises the correct error' do
expect { subject }
.to raise_error(::Packages::Rubygems::ProcessGemService::InvalidMetadataError, 'Invalid metadata')
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Rubygems
class MetadataExtractionService
def initialize(package, gemspec)
@package = package
@gemspec = gemspec
end
def execute
write_metadata
end
private
attr_reader :package, :gemspec
# rubocop:disable Metrics/AbcSize
# rubocop:disable Metrics/PerceivedComplexity
# rubocop:disable Metrics/CyclomaticComplexity
def write_metadata
metadatum.update!(
authors: gemspec&.authors,
files: gemspec&.files&.to_json,
summary: gemspec&.summary,
description: gemspec&.description,
email: gemspec&.email,
homepage: gemspec&.homepage,
licenses: gemspec&.licenses&.to_json,
metadata: gemspec&.metadata&.to_json,
author: gemspec&.author,
bindir: gemspec&.bindir,
executables: gemspec&.executables&.to_json,
extensions: gemspec&.extensions&.to_json,
extra_rdoc_files: gemspec&.extra_rdoc_files&.to_json,
platform: gemspec&.platform,
post_install_message: gemspec&.post_install_message,
rdoc_options: gemspec&.rdoc_options&.to_json,
require_paths: gemspec&.require_paths&.to_json,
required_ruby_version: gemspec&.required_ruby_version&.to_s,
required_rubygems_version: gemspec&.required_rubygems_version&.to_s,
requirements: gemspec&.requirements&.to_json,
rubygems_version: gemspec&.rubygems_version
)
end
# rubocop:enable Metrics/AbcSize
# rubocop:enable Metrics/PerceivedComplexity
# rubocop:enable Metrics/CyclomaticComplexity
def metadatum
# safe_find_or_create_by! was originally called here.
# We merely switched to `find_or_create_by!`
# rubocop: disable CodeReuse/ActiveRecord
Packages::Rubygems::Metadatum.find_or_create_by!(package: package)
# rubocop: enable CodeReuse/ActiveRecord
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
require 'rubygems/package'
RSpec.describe Packages::Rubygems::MetadataExtractionService, feature_category: :package_registry do
include RubygemsHelpers
let_it_be(:package) { create(:rubygems_package) }
let_it_be(:package_file) { create(:package_file, :gem) }
let_it_be(:gem) { gem_from_file(package_file.file) }
let_it_be(:gemspec) { gem.spec }
let(:service) { described_class.new(package, gemspec) }
describe '#execute' do
subject { service.execute }
it 'creates the metadata' do
expect { subject }.to change { Packages::Rubygems::Metadatum.count }.by(1)
end
it 'stores the metadata', :aggregate_failures do
subject
metadata = package.rubygems_metadatum
expect(metadata.authors).to eq(gemspec.authors.to_json)
expect(metadata.files).to eq(gemspec.files.to_json)
expect(metadata.summary).to eq(gemspec.summary)
expect(metadata.description).to eq(gemspec.description)
expect(metadata.email).to eq(gemspec.email)
expect(metadata.homepage).to eq(gemspec.homepage)
expect(metadata.licenses).to eq(gemspec.licenses.to_json)
expect(metadata.metadata).to eq(gemspec.metadata.to_json)
expect(metadata.author).to eq(gemspec.author)
expect(metadata.bindir).to eq(gemspec.bindir)
expect(metadata.executables).to eq(gemspec.executables.to_json)
expect(metadata.extensions).to eq(gemspec.extensions.to_json)
expect(metadata.extra_rdoc_files).to eq(gemspec.extra_rdoc_files.to_json)
expect(metadata.platform).to eq(gemspec.platform)
expect(metadata.post_install_message).to eq(gemspec.post_install_message)
expect(metadata.rdoc_options).to eq(gemspec.rdoc_options.to_json)
expect(metadata.require_paths).to eq(gemspec.require_paths.to_json)
expect(metadata.required_ruby_version).to eq(gemspec.required_ruby_version.to_s)
expect(metadata.required_rubygems_version).to eq(gemspec.required_rubygems_version.to_s)
expect(metadata.requirements).to eq(gemspec.requirements.to_json)
expect(metadata.rubygems_version).to eq(gemspec.rubygems_version)
end
context 'with an existing metadatum' do
let_it_be(:metadatum) { create(:rubygems_metadatum, package: package) }
it 'updates it' do
expect { subject }.not_to change { Packages::Rubygems::Metadatum.count }
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Rubygems
class CreateDependenciesService
def initialize(package, gemspec)
@package = package
@gemspec = gemspec
end
def execute
set_dependencies
end
private
attr_reader :package, :gemspec
def set_dependencies
Packages::Dependency.transaction do
dependency_type_rows = gemspec.dependencies.map do |dependency|
dependency = Packages::Dependency.safe_find_or_create_by!(
name: dependency.name,
version_pattern: dependency.requirement.to_s
)
{
dependency_id: dependency.id,
package_id: package.id,
dependency_type: :dependencies
}
end
package.dependency_links.upsert_all(
dependency_type_rows,
unique_by: %i[package_id dependency_id dependency_type]
)
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Rubygems::CreateDependenciesService, feature_category: :package_registry do
include RubygemsHelpers
let_it_be(:package) { create(:rubygems_package) }
let_it_be(:package_file) { create(:package_file, :gem) }
let_it_be(:gem) { gem_from_file(package_file.file) }
let_it_be(:gemspec) { gem.spec }
let(:service) { described_class.new(package, gemspec) }
describe '#execute' do
subject { service.execute }
it 'creates dependencies', :aggregate_failures do
expect { subject }.to change { Packages::Dependency.count }.by(4)
gemspec.dependencies.each do |dependency|
persisted_dependency = Packages::Dependency.find_by(name: dependency.name)
expect(persisted_dependency.version_pattern).to eq dependency.requirement.to_s
end
end
it 'links dependencies to the package' do
expect { subject }.to change { package.dependency_links.count }.by(4)
expect(package.dependency_links.first).to be_dependencies
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Rubygems
class CreateGemspecService
def initialize(package, gemspec)
@package = package
@gemspec = gemspec
end
def execute
write_gemspec_to_file
end
private
attr_reader :package, :gemspec
def write_gemspec_to_file
file = Tempfile.new
begin
content = gemspec.to_ruby
file.write(content)
file.flush
md5 = Gitlab::FIPS.enabled? ? nil : Digest::MD5.hexdigest(content)
package.package_files.create!(
file: file,
size: file.size,
file_name: "#{gemspec.name}.gemspec",
file_sha1: Digest::SHA1.hexdigest(content),
file_md5: md5,
file_sha256: Digest::SHA256.hexdigest(content)
)
ensure
file.close
file.unlink
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Rubygems::CreateGemspecService, feature_category: :package_registry do
include RubygemsHelpers
let_it_be(:package_file) { create(:package_file, :gem) }
let_it_be(:gem) { gem_from_file(package_file.file) }
let_it_be(:gemspec) { gem.spec }
let_it_be(:package) { package_file.package }
let(:service) { described_class.new(package, gemspec) }
describe '#execute' do
subject { service.execute }
it 'creates a new package file', :aggregate_failures do
expect { subject }.to change { package.package_files.count }.by(1)
gemspec_file = package.package_files.find_by(file_name: "#{gemspec.name}.gemspec")
expect(gemspec_file.file).not_to be_nil
expect(gemspec_file.size).not_to be_nil
expect(gemspec_file.file_md5).not_to be_nil
expect(gemspec_file.file_sha1).not_to be_nil
expect(gemspec_file.file_sha256).not_to be_nil
end
context 'with FIPS mode', :fips_mode do
it 'does not generate file_md5' do
expect { subject }.to change { package.package_files.count }.by(1)
gemspec_file = package.package_files.find_by(file_name: "#{gemspec.name}.gemspec")
expect(gemspec_file.file).not_to be_nil
expect(gemspec_file.size).not_to be_nil
expect(gemspec_file.file_md5).to be_nil
expect(gemspec_file.file_sha1).not_to be_nil
expect(gemspec_file.file_sha256).not_to be_nil
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Cleanup
class UpdatePolicyService < BaseProjectService
ALLOWED_ATTRIBUTES = %i[keep_n_duplicated_package_files].freeze
def execute
return ServiceResponse.error(message: 'Access denied') unless allowed?
if policy.update(policy_params)
ServiceResponse.success(payload: { packages_cleanup_policy: policy })
else
ServiceResponse.error(message: policy.errors.full_messages.to_sentence || 'Bad request')
end
end
private
def policy
project.packages_cleanup_policy
end
strong_memoize_attr :policy
def allowed?
can?(current_user, :admin_package, project)
end
def policy_params
params.slice(*ALLOWED_ATTRIBUTES)
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Cleanup::UpdatePolicyService, feature_category: :package_registry do
using RSpec::Parameterized::TableSyntax
let_it_be_with_reload(:project) { create(:project) }
let_it_be(:current_user) { create(:user) }
let(:params) { { keep_n_duplicated_package_files: 50 } }
describe '#execute' do
subject { described_class.new(project: project, current_user: current_user, params: params).execute }
shared_examples 'creating the policy' do
it 'creates a new one' do
expect { subject }.to change { ::Packages::Cleanup::Policy.count }.from(0).to(1)
expect(subject.payload[:packages_cleanup_policy]).to be_present
expect(subject.success?).to be_truthy
expect(project.packages_cleanup_policy).to be_persisted
expect(project.packages_cleanup_policy.keep_n_duplicated_package_files).to eq('50')
end
context 'with invalid parameters' do
let(:params) { { keep_n_duplicated_package_files: 100 } }
it 'does not create one' do
expect { subject }.not_to change { ::Packages::Cleanup::Policy.count }
expect(subject.status).to eq(:error)
expect(subject.message).to eq('Keep n duplicated package files is invalid')
end
end
end
shared_examples 'updating the policy' do
it 'updates the existing one' do
expect { subject }.not_to change { ::Packages::Cleanup::Policy.count }
expect(subject.payload[:packages_cleanup_policy]).to be_present
expect(subject.success?).to be_truthy
expect(project.packages_cleanup_policy.keep_n_duplicated_package_files).to eq('50')
end
context 'with invalid parameters' do
let(:params) { { keep_n_duplicated_package_files: 100 } }
it 'does not update one' do
expect { subject }.not_to change { policy.keep_n_duplicated_package_files }
expect(subject.status).to eq(:error)
expect(subject.message).to eq('Keep n duplicated package files is invalid')
end
end
end
shared_examples 'denying access' do
it 'returns an error' do
subject
expect(subject.message).to eq('Access denied')
expect(subject.status).to eq(:error)
end
end
context 'with existing container expiration policy' do
let_it_be(:policy) { create(:packages_cleanup_policy, project: project) }
where(:user_role, :shared_examples_name) do
:maintainer | 'updating the policy'
:developer | 'denying access'
:reporter | 'denying access'
:guest | 'denying access'
:anonymous | 'denying access'
end
with_them do
before do
project.send("add_#{user_role}", current_user) unless user_role == :anonymous
end
it_behaves_like params[:shared_examples_name]
end
end
context 'without existing container expiration policy' do
where(:user_role, :shared_examples_name) do
:maintainer | 'creating the policy'
:developer | 'denying access'
:reporter | 'denying access'
:guest | 'denying access'
:anonymous | 'denying access'
end
with_them do
before do
project.send("add_#{user_role}", current_user) unless user_role == :anonymous
end
it_behaves_like params[:shared_examples_name]
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Cleanup
class ExecutePolicyService
include Gitlab::Utils::StrongMemoize
MAX_EXECUTION_TIME = 250.seconds
DUPLICATED_FILES_BATCH_SIZE = 10_000
MARK_PACKAGE_FILES_FOR_DESTRUCTION_SERVICE_BATCH_SIZE = 200
def initialize(policy)
@policy = policy
@counts = {
marked_package_files_total_count: 0,
unique_package_id_and_file_name_total_count: 0
}
end
def execute
cleanup_duplicated_files
end
private
def cleanup_duplicated_files
return if @policy.keep_n_duplicated_package_files_disabled?
result = installable_package_files.each_batch(of: DUPLICATED_FILES_BATCH_SIZE) do |package_files|
break :timeout if cleanup_duplicated_files_on(package_files) == :timeout
end
response_success(timeout: result == :timeout)
end
def cleanup_duplicated_files_on(package_files)
unique_package_id_and_file_name_from(package_files).each do |package_id, file_name|
result = remove_duplicated_files_for(package_id: package_id, file_name: file_name)
@counts[:marked_package_files_total_count] += result.payload[:marked_package_files_count]
@counts[:unique_package_id_and_file_name_total_count] += 1
break :timeout unless result.success?
end
end
def unique_package_id_and_file_name_from(package_files)
# This is a highly custom query for this service, that's why it's not in the model.
# rubocop: disable CodeReuse/ActiveRecord
package_files.group(:package_id, :file_name)
.having("COUNT(*) > #{@policy.keep_n_duplicated_package_files}")
.pluck(:package_id, :file_name)
# rubocop: enable CodeReuse/ActiveRecord
end
def remove_duplicated_files_for(package_id:, file_name:)
base = ::Packages::PackageFile.for_package_ids(package_id)
.installable
.with_file_name(file_name)
ids_to_keep = base.recent
.limit(@policy.keep_n_duplicated_package_files)
.pluck_primary_key
duplicated_package_files = base.id_not_in(ids_to_keep)
::Packages::MarkPackageFilesForDestructionService.new(duplicated_package_files)
.execute(batch_deadline: batch_deadline, batch_size: MARK_PACKAGE_FILES_FOR_DESTRUCTION_SERVICE_BATCH_SIZE)
end
def project
@policy.project
end
def installable_package_files
::Packages::PackageFile.installable
.for_package_ids(
::Packages::Package.installable
.for_projects(project.id)
)
end
def batch_deadline
MAX_EXECUTION_TIME.from_now
end
strong_memoize_attr :batch_deadline
def response_success(timeout:)
ServiceResponse.success(
message: "Packages cleanup policy executed for project #{project.id}",
payload: {
timeout: timeout,
counts: @counts
}
)
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Cleanup::ExecutePolicyService, feature_category: :package_registry do
let_it_be(:project) { create(:project) }
let_it_be_with_reload(:policy) { create(:packages_cleanup_policy, project: project) }
let(:service) { described_class.new(policy) }
describe '#execute' do
subject(:execute) { service.execute }
context 'with the keep_n_duplicated_files parameter' do
let_it_be(:package1) { create(:package, project: project) }
let_it_be(:package2) { create(:package, project: project) }
let_it_be(:package3) { create(:package, project: project) }
let_it_be(:package4) { create(:package, :pending_destruction, project: project) }
let_it_be(:package_file1_1) { create(:package_file, package: package1, file_name: 'file_name1') }
let_it_be(:package_file1_2) { create(:package_file, package: package1, file_name: 'file_name1') }
let_it_be(:package_file1_3) { create(:package_file, package: package1, file_name: 'file_name1') }
let_it_be(:package_file1_4) { create(:package_file, package: package1, file_name: 'file_name2') }
let_it_be(:package_file1_5) { create(:package_file, package: package1, file_name: 'file_name2') }
let_it_be(:package_file1_6) { create(:package_file, package: package1, file_name: 'file_name2') }
let_it_be(:package_file1_7) do
create(:package_file, :pending_destruction, package: package1, file_name: 'file_name2')
end
let_it_be(:package_file2_1) { create(:package_file, package: package2, file_name: 'file_name1') }
let_it_be(:package_file2_2) { create(:package_file, package: package2, file_name: 'file_name1') }
let_it_be(:package_file2_3) { create(:package_file, package: package2, file_name: 'file_name1') }
let_it_be(:package_file2_4) { create(:package_file, package: package2, file_name: 'file_name1') }
let_it_be(:package_file3_1) { create(:package_file, package: package3, file_name: 'file_name_test') }
let_it_be(:package_file4_1) { create(:package_file, package: package4, file_name: 'file_name1') }
let_it_be(:package_file4_2) { create(:package_file, package: package4, file_name: 'file_name1') }
let(:package_files_1) { package1.package_files.installable }
let(:package_files_2) { package2.package_files.installable }
let(:package_files_3) { package3.package_files.installable }
context 'set to less than the total number of duplicated files' do
before do
# for each package file duplicate, we keep only the most recent one
policy.update!(keep_n_duplicated_package_files: '1')
end
shared_examples 'keeping the most recent package files' do
let(:response_payload) do
{
counts: {
marked_package_files_total_count: 7,
unique_package_id_and_file_name_total_count: 3
},
timeout: false
}
end
it 'only keeps the most recent package files' do
expect { execute }.to change { ::Packages::PackageFile.installable.count }.by(-7)
expect(package_files_1).to contain_exactly(package_file1_3, package_file1_6)
expect(package_files_2).to contain_exactly(package_file2_4)
expect(package_files_3).to contain_exactly(package_file3_1)
expect(execute).to be_success
expect(execute.message).to eq("Packages cleanup policy executed for project #{project.id}")
expect(execute.payload).to eq(response_payload)
end
end
it_behaves_like 'keeping the most recent package files'
context 'when the service needs to loop' do
before do
stub_const("#{described_class.name}::DUPLICATED_FILES_BATCH_SIZE", 2)
end
it_behaves_like 'keeping the most recent package files' do
before do
expect(::Packages::MarkPackageFilesForDestructionService)
.to receive(:new).exactly(3).times.and_call_original
end
end
context 'when a timeout is hit' do
let(:response_payload) do
{
counts: {
marked_package_files_total_count: 4,
unique_package_id_and_file_name_total_count: 3
},
timeout: true
}
end
let(:service_timeout_response) do
ServiceResponse.error(
message: 'Timeout while marking package files as pending destruction',
payload: { marked_package_files_count: 0 }
)
end
before do
mock_service_timeout(on_iteration: 3)
end
it 'keeps part of the most recent package files' do
expect { execute }
.to change { ::Packages::PackageFile.installable.count }.by(-4)
.and not_change { package_files_2.count } # untouched because of the timeout
.and not_change { package_files_3.count } # untouched because of the timeout
expect(package_files_1).to contain_exactly(package_file1_3, package_file1_6)
expect(execute).to be_success
expect(execute.message).to eq("Packages cleanup policy executed for project #{project.id}")
expect(execute.payload).to eq(response_payload)
end
def mock_service_timeout(on_iteration:)
execute_call_count = 1
expect_next_instances_of(::Packages::MarkPackageFilesForDestructionService, 3) do |service|
expect(service).to receive(:execute).and_wrap_original do |m, *args, **kwargs|
# timeout if we are on the right iteration
if execute_call_count == on_iteration
service_timeout_response
else
execute_call_count += 1
m.call(*args, **kwargs)
end
end
end
end
end
end
end
context 'set to more than the total number of duplicated files' do
before do
# using the biggest value for keep_n_duplicated_package_files
policy.update!(keep_n_duplicated_package_files: '50')
end
it 'keeps all package files' do
expect { execute }.not_to change { ::Packages::PackageFile.installable.count }
end
end
context 'set to all' do
before do
policy.update!(keep_n_duplicated_package_files: 'all')
end
it 'skips the policy' do
expect(::Packages::MarkPackageFilesForDestructionService).not_to receive(:new)
expect { execute }.not_to change { ::Packages::PackageFile.installable.count }
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Protection
class UpdateRuleService
include Gitlab::Allowable
ALLOWED_ATTRIBUTES = %i[
package_name_pattern
package_type
push_protected_up_to_access_level
].freeze
def initialize(package_protection_rule, current_user:, params:)
if package_protection_rule.blank? || current_user.blank?
raise ArgumentError,
'package_protection_rule and current_user must be set'
end
@package_protection_rule = package_protection_rule
@current_user = current_user
@params = params || {}
end
def execute
unless can?(current_user, :admin_package, package_protection_rule.project)
error_message = _('Unauthorized to update a package protection rule')
return service_response_error(message: error_message)
end
package_protection_rule.update(params.slice(*ALLOWED_ATTRIBUTES))
if package_protection_rule.errors.present?
return service_response_error(message: package_protection_rule.errors.full_messages)
end
ServiceResponse.success(payload: { package_protection_rule: package_protection_rule })
rescue StandardError => e
service_response_error(message: e.message)
end
private
attr_reader :package_protection_rule, :current_user, :params
def service_response_error(message:)
ServiceResponse.error(
message: message,
payload: { package_protection_rule: nil }
)
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Protection::UpdateRuleService, '#execute', feature_category: :environment_management do
let_it_be(:project) { create(:project, :repository) }
let_it_be(:current_user) { create(:user, maintainer_projects: [project]) }
let_it_be_with_reload(:package_protection_rule) { create(:package_protection_rule, project: project) }
let(:service) { described_class.new(package_protection_rule, current_user: current_user, params: params) }
let(:params) do
attributes_for(
:package_protection_rule,
package_name_pattern: "#{package_protection_rule.package_name_pattern}-updated",
package_type: 'npm',
push_protected_up_to_access_level: 'owner'
)
end
subject(:service_execute) { service.execute }
shared_examples 'a successful service response' do
let(:expected_attributes) { params }
it { is_expected.to be_success }
it do
is_expected.to have_attributes(
errors: be_blank,
message: be_blank,
payload: { package_protection_rule: be_a(Packages::Protection::Rule).and(have_attributes(expected_attributes)) }
)
end
it { expect { subject }.not_to change { Packages::Protection::Rule.count } }
it { subject.tap { expect(package_protection_rule.reload).to have_attributes expected_attributes } }
end
shared_examples 'an erroneous service response' do
it { is_expected.to be_error }
it do
is_expected.to have_attributes(
errors: be_present,
message: be_present,
payload: { package_protection_rule: nil }
)
end
it { expect { subject }.not_to change { Packages::Protection::Rule.count } }
it { expect { subject }.not_to change { package_protection_rule.reload.updated_at } }
end
it_behaves_like 'a successful service response'
context 'with disallowed params' do
let(:params) { super().merge!(project_id: 1, unsupported_param: 'unsupported_param_value') }
it_behaves_like 'a successful service response' do
let(:expected_attributes) { params.except(:project_id, :unsupported_param) }
end
end
context 'when fields are invalid' do
let(:params) do
{ package_name_pattern: '', package_type: 'unknown_package_type',
push_protected_up_to_access_level: 1000 }
end
it_behaves_like 'an erroneous service response'
it { is_expected.to have_attributes message: /'unknown_package_type' is not a valid package_type/ }
end
context 'with empty params' do
let(:params) { {} }
it_behaves_like 'a successful service response' do
let(:expected_attributes) { package_protection_rule.attributes }
end
it { expect { service_execute }.not_to change { package_protection_rule.reload.updated_at } }
end
context 'with nil params' do
let(:params) { nil }
it_behaves_like 'a successful service response' do
let(:expected_attributes) { package_protection_rule.attributes }
end
it { expect { service_execute }.not_to change { package_protection_rule.reload.updated_at } }
end
context 'when updated field `package_name_pattern` is already taken' do
let_it_be_with_reload(:other_existing_package_protection_rule) do
create(:package_protection_rule, project: project,
package_name_pattern: "#{package_protection_rule.package_name_pattern}-other")
end
let(:params) { { package_name_pattern: other_existing_package_protection_rule.package_name_pattern } }
it_behaves_like 'an erroneous service response'
it do
expect { service_execute }.not_to(
change { other_existing_package_protection_rule.reload.package_name_pattern }
)
end
it do
is_expected.to have_attributes(
errors: match_array([/Package name pattern has already been taken/]),
message: match_array([/Package name pattern has already been taken/])
)
end
end
context 'when current_user does not have permission' do
let_it_be(:developer) { create(:user).tap { |u| project.add_developer(u) } }
let_it_be(:reporter) { create(:user).tap { |u| project.add_reporter(u) } }
let_it_be(:guest) { create(:user).tap { |u| project.add_guest(u) } }
let_it_be(:anonymous) { create(:user) }
where(:current_user) do
[ref(:developer), ref(:reporter), ref(:guest), ref(:anonymous)]
end
with_them do
it_behaves_like 'an erroneous service response'
it { is_expected.to have_attributes errors: match_array(/Unauthorized/), message: /Unauthorized/ }
end
end
context 'without package protection rule' do
let(:package_protection_rule) { nil }
let(:params) { {} }
it { expect { service_execute }.to raise_error(ArgumentError) }
end
context 'without current_user' do
let(:current_user) { nil }
it { expect { service_execute }.to raise_error(ArgumentError) }
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Protection
class CreateRuleService < BaseProjectService
ALLOWED_ATTRIBUTES = %i[
package_name_pattern
package_type
push_protected_up_to_access_level
].freeze
def execute
unless can?(current_user, :admin_package, project)
error_message = _('Unauthorized to create a package protection rule')
return service_response_error(message: error_message)
end
package_protection_rule = project.package_protection_rules.create(params.slice(*ALLOWED_ATTRIBUTES))
unless package_protection_rule.persisted?
return service_response_error(message: package_protection_rule.errors.full_messages)
end
ServiceResponse.success(payload: { package_protection_rule: package_protection_rule })
rescue StandardError => e
service_response_error(message: e.message)
end
private
def service_response_error(message:)
ServiceResponse.error(
message: message,
payload: { package_protection_rule: nil }
)
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Protection::CreateRuleService, '#execute', feature_category: :package_registry do
let_it_be(:project) { create(:project, :repository) }
let_it_be(:maintainer) { create(:user).tap { |u| project.add_maintainer(u) } }
let(:service) { described_class.new(project: project, current_user: current_user, params: params) }
let(:current_user) { maintainer }
let(:params) { attributes_for(:package_protection_rule) }
subject { service.execute }
shared_examples 'a successful service response' do
let(:package_protection_rule_count_expected) { 1 }
it { is_expected.to be_success }
it do
is_expected.to have_attributes(
payload: include(
package_protection_rule: be_a(Packages::Protection::Rule)
)
)
end
it { expect(subject.payload).to include(package_protection_rule: be_a(Packages::Protection::Rule)) }
it do
expect { subject }.to change { Packages::Protection::Rule.count }.by(1)
expect(Packages::Protection::Rule.where(project: project).count).to eq package_protection_rule_count_expected
expect(Packages::Protection::Rule.where(project: project,
package_name_pattern: params[:package_name_pattern])).to exist
end
end
shared_examples 'an erroneous service response' do
let(:package_protection_rule_count_expected) { 0 }
it { is_expected.to be_error }
it { is_expected.to have_attributes(payload: include(package_protection_rule: nil)) }
it do
expect { subject }.to change { Packages::Protection::Rule.count }.by(0)
expect(Packages::Protection::Rule.where(project: project).count).to eq package_protection_rule_count_expected
expect(Packages::Protection::Rule.where(project: project,
package_name_pattern: params[:package_name_pattern])).not_to exist
end
end
context 'without existing PackageProtectionRules' do
context 'when fields are valid' do
it_behaves_like 'a successful service response'
end
context 'when fields are invalid' do
let(:params) do
{
package_name_pattern: '',
package_type: 'unknown_package_type',
push_protected_up_to_access_level: 1000
}
end
it_behaves_like 'an erroneous service response'
end
end
context 'with existing PackageProtectionRule' do
let_it_be(:existing_package_protection_rule) { create(:package_protection_rule, project: project) }
context 'when package name pattern is slightly different' do
let(:params) do
attributes_for(
:package_protection_rule,
# The field `package_name_pattern` is unique; this is why we change the value in a minimum way
package_name_pattern: "#{existing_package_protection_rule.package_name_pattern}-unique",
package_type: existing_package_protection_rule.package_type,
push_protected_up_to_access_level: existing_package_protection_rule.push_protected_up_to_access_level
)
end
it_behaves_like 'a successful service response' do
let(:package_protection_rule_count_expected) { 2 }
end
end
context 'when field `package_name_pattern` is taken' do
let(:params) do
attributes_for(
:package_protection_rule,
package_name_pattern: existing_package_protection_rule.package_name_pattern,
package_type: existing_package_protection_rule.package_type,
push_protected_up_to_access_level: existing_package_protection_rule.push_protected_up_to_access_level
)
end
it { is_expected.to be_error }
it do
expect { subject }.to change { Packages::Protection::Rule.count }.by(0)
expect(Packages::Protection::Rule.where(project: project).count).to eq 1
expect(
Packages::Protection::Rule.where(
project: project,
package_name_pattern: params[:package_name_pattern]
)
).to exist
end
end
end
context 'when disallowed params are passed' do
let(:params) do
attributes_for(:package_protection_rule)
.merge(
project_id: 1,
unsupported_param: 'unsupported_param_value'
)
end
it_behaves_like 'a successful service response'
end
context 'with forbidden user access level (project developer role)' do
# Because of the access level hierarchy, we can assume that
# other access levels below developer role will also not be able to
# create package protection rules.
let_it_be(:developer) { create(:user).tap { |u| project.add_developer(u) } }
let(:current_user) { developer }
it_behaves_like 'an erroneous service response'
it { is_expected.to have_attributes(message: match(/Unauthorized/)) }
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Protection
class DeleteRuleService
include Gitlab::Allowable
def initialize(package_protection_rule, current_user:)
if package_protection_rule.blank? || current_user.blank?
raise ArgumentError,
'package_protection_rule and current_user must be set'
end
@package_protection_rule = package_protection_rule
@current_user = current_user
end
def execute
unless can?(current_user, :admin_package, package_protection_rule.project)
error_message = _('Unauthorized to delete a package protection rule')
return service_response_error(message: error_message)
end
deleted_package_protection_rule = package_protection_rule.destroy!
ServiceResponse.success(payload: { package_protection_rule: deleted_package_protection_rule })
rescue StandardError => e
service_response_error(message: e.message)
end
private
attr_reader :package_protection_rule, :current_user
def service_response_error(message:)
ServiceResponse.error(
message: message,
payload: { package_protection_rule: nil }
)
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Protection::DeleteRuleService, '#execute', feature_category: :package_registry do
let_it_be(:project) { create(:project) }
let_it_be(:current_user) { create(:user, maintainer_projects: [project]) }
let_it_be_with_refind(:package_protection_rule) { create(:package_protection_rule, project: project) }
subject { described_class.new(package_protection_rule, current_user: current_user).execute }
shared_examples 'a successful service response' do
it { is_expected.to be_success }
it {
is_expected.to have_attributes(
errors: be_blank,
message: be_blank,
payload: { package_protection_rule: package_protection_rule }
)
}
it { subject.tap { expect { package_protection_rule.reload }.to raise_error ActiveRecord::RecordNotFound } }
end
shared_examples 'an erroneous service response' do
it { is_expected.to be_error }
it { is_expected.to have_attributes(message: be_present, payload: { package_protection_rule: be_blank }) }
it do
expect { subject }.not_to change { Packages::Protection::Rule.count }
expect { package_protection_rule.reload }.not_to raise_error
end
end
it_behaves_like 'a successful service response'
it 'deletes the package protection rule in the database' do
expect { subject }
.to change { project.reload.package_protection_rules }.from([package_protection_rule]).to([])
.and change { ::Packages::Protection::Rule.count }.from(1).to(0)
end
context 'with deleted package protection rule' do
let!(:package_protection_rule) do
create(:package_protection_rule, project: project, package_name_pattern: 'protection_rule_deleted').destroy!
end
it_behaves_like 'a successful service response'
end
context 'when error occurs during delete operation' do
before do
allow(package_protection_rule).to receive(:destroy!).and_raise(StandardError.new('Some error'))
end
it_behaves_like 'an erroneous service response'
it { is_expected.to have_attributes message: /Some error/ }
end
context 'when current_user does not have permission' do
let_it_be(:developer) { create(:user).tap { |u| project.add_developer(u) } }
let_it_be(:reporter) { create(:user).tap { |u| project.add_reporter(u) } }
let_it_be(:guest) { create(:user).tap { |u| project.add_guest(u) } }
let_it_be(:anonymous) { create(:user) }
where(:current_user) do
[ref(:developer), ref(:reporter), ref(:guest), ref(:anonymous)]
end
with_them do
it_behaves_like 'an erroneous service response'
it { is_expected.to have_attributes message: /Unauthorized to delete a package protection rule/ }
end
end
context 'without package protection rule' do
let(:package_protection_rule) { nil }
it { expect { subject }.to raise_error(ArgumentError) }
end
context 'without current_user' do
let(:current_user) { nil }
let(:package_protection_rule) { build_stubbed(:package_protection_rule, project: project) }
it { expect { subject }.to raise_error(ArgumentError) }
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Nuget
class ExtractRemoteMetadataFileService
include Gitlab::Utils::StrongMemoize
ExtractionError = Class.new(StandardError)
MAX_FILE_SIZE = 4.megabytes.freeze
METADATA_FILE_EXTENSION = '.nuspec'
MAX_FRAGMENTS = 5 # nuspec file is usually in the first 2 fragments but we buffer 5 max
def initialize(remote_url)
@remote_url = remote_url
end
def execute
raise ExtractionError, 'invalid file url' if remote_url.blank?
if nuspec_file_content.blank? || !nuspec_file_content.instance_of?(String)
raise ExtractionError, 'nuspec file not found'
end
ServiceResponse.success(payload: nuspec_file_content)
end
private
attr_reader :remote_url
def nuspec_file_content
fragments = []
Gitlab::HTTP.get(remote_url, stream_body: true, allow_object_storage: true) do |fragment|
break if fragments.size >= MAX_FRAGMENTS
fragments << fragment
joined_fragments = fragments.join
next if joined_fragments.exclude?(METADATA_FILE_EXTENSION)
nuspec_content = extract_nuspec_file(joined_fragments)
break nuspec_content if nuspec_content.present?
end
end
strong_memoize_attr :nuspec_file_content
def extract_nuspec_file(fragments)
StringIO.open(fragments) do |io|
Zip::InputStream.open(io) do |zip|
process_zip_entries(zip)
end
rescue Zip::Error => e
raise ExtractionError, "Error opening zip stream: #{e.message}"
end
end
def process_zip_entries(zip)
while (entry = zip.get_next_entry) # rubocop:disable Lint/AssignmentInCondition
next unless entry.name.end_with?(METADATA_FILE_EXTENSION)
raise ExtractionError, 'nuspec file too big' if entry.size > MAX_FILE_SIZE
return extract_file_content(entry)
end
end
def extract_file_content(entry)
Tempfile.create('extract_remote_metadata_file_service') do |file|
entry.extract(file.path) { true } # allow #extract to overwrite the file
file.read
end
rescue Zip::DecompressionError
'' # Ignore decompression errors and continue reading the next fragment
rescue Zip::EntrySizeError => e
raise ExtractionError, "nuspec file has the wrong entry size: #{e.message}"
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Nuget::ExtractRemoteMetadataFileService, feature_category: :package_registry do
let_it_be(:remote_url) { 'http://example.com/package.nupkg' }
let_it_be(:nupkg_filepath) { 'packages/nuget/package.nupkg' }
describe '#execute' do
subject(:service) { described_class.new(remote_url) }
context 'when the remote URL is blank' do
let(:remote_url) { '' }
it { expect { service.execute }.to raise_error(described_class::ExtractionError, 'invalid file url') }
end
context 'when the package file is corrupted' do
before do
allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
.and_yield('corrupted data')
end
it { expect { service.execute }.to raise_error(described_class::ExtractionError, 'nuspec file not found') }
end
context 'when reaching the maximum received fragments' do
before do
allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
.and_yield('Fragment 1').and_yield('Fragment 2').and_yield('Fragment 3').and_yield('Fragment 4')
.and_yield('Fragment 5').and_yield(fixture_file(nupkg_filepath))
end
it { expect { service.execute }.to raise_error(described_class::ExtractionError, 'nuspec file not found') }
end
context 'when nuspec file is too big' do
before do
allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
.and_yield(fixture_file(nupkg_filepath))
allow_next_instance_of(Zip::Entry) do |instance|
allow(instance).to receive(:size).and_return(6.megabytes)
end
end
it { expect { service.execute }.to raise_error(described_class::ExtractionError, 'nuspec file too big') }
end
context 'when nuspec file is fragmented' do
let_it_be(:nuspec_path) { expand_fixture_path('packages/nuget/with_metadata.nuspec') }
let_it_be(:tmp_zip) { Tempfile.new('nuget_zip') }
let_it_be(:zipped_nuspec) { zip_nuspec_file(nuspec_path, tmp_zip.path).get_raw_input_stream.read }
let_it_be(:fragments) { zipped_nuspec.chars.each_slice(zipped_nuspec.size / 2).map(&:join) }
before do
allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
.and_yield(fragments[0]).and_yield(fragments[1])
end
after do
tmp_zip.unlink
end
it 'ignores the Zip::DecompressionError and constructs the nuspec file from the fragments' do
response = service.execute
expect(response).to be_success
expect(response.payload).to include('<id>DummyProject.WithMetadata</id>')
.and include('<version>1.2.3</version>')
end
end
context 'when the remote URL is valid' do
let(:fragments) { fixture_file(nupkg_filepath).chars.each_slice(1.kilobyte).map(&:join) }
before do
allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
.and_yield(fragments[0]).and_yield(fragments[1]).and_yield(fragments[2]).and_yield(fragments[3])
end
it 'returns a success response with the nuspec file content' do
response = service.execute
expect(response).to be_success
expect(response.payload).to include('<id>DummyProject.DummyPackage</id>')
.and include('<version>1.0.0</version>')
end
end
context 'with a corrupted nupkg file with a wrong entry size' do
before do
allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
.and_yield(fixture_file(nupkg_filepath))
allow_next_instance_of(Zip::Entry) do |instance|
allow(instance).to receive(:extract).and_raise(Zip::EntrySizeError)
end
end
it {
expect do
service.execute
end.to raise_error(described_class::ExtractionError, /nuspec file has the wrong entry size/)
}
end
context 'with a Zip::Error exception' do
before do
allow(Gitlab::HTTP).to receive(:get).with(remote_url, stream_body: true, allow_object_storage: true)
.and_yield(fixture_file(nupkg_filepath))
allow(Zip::InputStream).to receive(:open).and_raise(Zip::Error)
end
it {
expect do
service.execute
end.to raise_error(described_class::ExtractionError, /Error opening zip stream/)
}
end
end
def zip_nuspec_file(nuspec_path, zip_path)
Zip::File.open(zip_path, Zip::File::CREATE) do |zipfile|
zipfile.add('package.nuspec', nuspec_path)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Nuget
class MetadataExtractionService
def initialize(package_zip_file)
@package_zip_file = package_zip_file
end
def execute
ServiceResponse.success(payload: metadata)
end
private
attr_reader :package_zip_file
def metadata
::Packages::Nuget::ExtractMetadataContentService
.new(nuspec_file_content)
.execute
.payload
end
def nuspec_file_content
::Packages::Nuget::ExtractMetadataFileService
.new(package_zip_file)
.execute
.payload
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Nuget::MetadataExtractionService, feature_category: :package_registry do
let_it_be(:package_file) { build(:package_file, :nuget) }
let(:package_zip_file) { Zip::File.new(package_file.file) }
let(:service) { described_class.new(package_zip_file) }
describe '#execute' do
subject { service.execute }
let(:nuspec_file_content) do
<<~XML
<?xml version="1.0" encoding="utf-8"?>
<package xmlns="http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd">
<metadata>
<id>DummyProject.DummyPackage</id>
<version>1.0.0</version>
<title>Dummy package</title>
<authors>Test</authors>
<owners>Test</owners>
<requireLicenseAcceptance>false</requireLicenseAcceptance>
<description>This is a dummy project</description>
<dependencies>
<group targetFramework=".NETCoreApp3.0">
<dependency id="Newtonsoft.Json" version="12.0.3" exclude="Build,Analyzers" />
</group>
</dependencies>
</metadata>
</package>
XML
end
let(:expected_metadata) do
{
package_name: 'DummyProject.DummyPackage',
package_version: '1.0.0',
authors: 'Test',
description: 'This is a dummy project',
package_dependencies: [
{
name: 'Newtonsoft.Json',
target_framework: '.NETCoreApp3.0',
version: '12.0.3'
}
],
package_tags: [],
package_types: []
}
end
it 'calls the necessary services and executes the metadata extraction' do
expect_next_instance_of(Packages::Nuget::ExtractMetadataFileService, package_zip_file) do |service|
expect(service).to receive(:execute).and_return(ServiceResponse.success(payload: nuspec_file_content))
end
expect_next_instance_of(Packages::Nuget::ExtractMetadataContentService, nuspec_file_content) do |service|
expect(service).to receive(:execute).and_call_original
end
expect(subject.payload).to eq(expected_metadata)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Nuget
class ExtractMetadataFileService
ExtractionError = Class.new(StandardError)
MAX_FILE_SIZE = 4.megabytes.freeze
def initialize(package_zip_file)
@package_zip_file = package_zip_file
end
def execute
ServiceResponse.success(payload: nuspec_file_content)
end
private
attr_reader :package_zip_file
def nuspec_file_content
entry = extract_nuspec_file
raise ExtractionError, 'nuspec file not found' unless entry
raise ExtractionError, 'nuspec file too big' if MAX_FILE_SIZE < entry.size
Tempfile.create('nuget_extraction_package_file') do |file|
entry.extract(file.path) { true } # allow #extract to overwrite the file
file.read
end
rescue Zip::EntrySizeError => e
raise ExtractionError, "nuspec file has the wrong entry size: #{e.message}"
end
def extract_nuspec_file
if package_zip_file.is_a?(Zip::InputStream)
while (entry = package_zip_file.get_next_entry) # rubocop:disable Lint/AssignmentInCondition -- Following https://github.com/rubyzip/rubyzip#notes-on-zipinputstream and that's why the disable rubocop rule
break entry if entry.name.end_with?('.nuspec')
end
else
package_zip_file.glob('*.nuspec').first
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Nuget::ExtractMetadataFileService, feature_category: :package_registry do
include PackagesManagerApiSpecHelpers
let_it_be(:package_file) { build(:package_file, :nuget) }
let_it_be(:package_zip_file) { Zip::File.new(package_file.file) }
let(:service) { described_class.new(package_zip_file) }
describe '#execute' do
subject { service.execute }
shared_examples 'raises an error' do |error_message|
it { expect { subject }.to raise_error(described_class::ExtractionError, error_message) }
end
context 'with valid package file' do
expected_metadata = <<~XML.squish
<package xmlns="http://schemas.microsoft.com/packaging/2013/05/nuspec.xsd">
<metadata>
<id>DummyProject.DummyPackage</id>
<version>1.0.0</version>
<title>Dummy package</title>
<authors>Test</authors>
<owners>Test</owners>
<requireLicenseAcceptance>false</requireLicenseAcceptance>
<description>This is a dummy project</description>
<dependencies>
<group targetFramework=".NETCoreApp3.0">
<dependency id="Newtonsoft.Json" version="12.0.3" exclude="Build,Analyzers" />
</group>
</dependencies>
</metadata>
</package>
XML
it 'returns the nuspec file content' do
expect(subject.payload.squish).to include(expected_metadata)
end
context 'with InputStream zip' do
let(:package_zip_file) do
Zip::InputStream.open(
temp_file('package.nupkg', content: File.open(package_file.file.path))
)
end
it 'returns the nuspec file content' do
expect(subject.payload.squish).to include(expected_metadata)
end
end
end
context 'without the nuspec file' do
before do
allow(package_zip_file).to receive(:glob).and_return([])
end
it_behaves_like 'raises an error', 'nuspec file not found'
end
context 'with a too big nuspec file' do
before do
allow(package_zip_file).to receive(:glob).and_return(
[instance_double(File, size: described_class::MAX_FILE_SIZE + 1)]
)
end
it_behaves_like 'raises an error', 'nuspec file too big'
end
context 'with a corrupted nupkg file with a wrong entry size' do
let(:nupkg_fixture_path) { expand_fixture_path('packages/nuget/corrupted_package.nupkg') }
let(:package_zip_file) { Zip::File.new(nupkg_fixture_path) }
it_behaves_like 'raises an error',
<<~ERROR.squish
nuspec file has the wrong entry size: entry 'DummyProject.DummyPackage.nuspec' should be 255B,
but is larger when inflated.
ERROR
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Nuget
class ExtractMetadataContentService
ROOT_XPATH = '//xmlns:package/xmlns:metadata/xmlns'
XPATHS = {
package_name: "#{ROOT_XPATH}:id",
package_version: "#{ROOT_XPATH}:version",
authors: "#{ROOT_XPATH}:authors",
description: "#{ROOT_XPATH}:description",
license_url: "#{ROOT_XPATH}:licenseUrl",
project_url: "#{ROOT_XPATH}:projectUrl",
icon_url: "#{ROOT_XPATH}:iconUrl"
}.freeze
XPATH_DEPENDENCIES = "#{ROOT_XPATH}:dependencies/xmlns:dependency".freeze
XPATH_DEPENDENCY_GROUPS = "#{ROOT_XPATH}:dependencies/xmlns:group".freeze
XPATH_TAGS = "#{ROOT_XPATH}:tags".freeze
XPATH_PACKAGE_TYPES = "#{ROOT_XPATH}:packageTypes/xmlns:packageType".freeze
def initialize(nuspec_file_content)
@nuspec_file_content = nuspec_file_content
end
def execute
ServiceResponse.success(payload: extract_metadata(nuspec_file_content))
end
private
attr_reader :nuspec_file_content
def extract_metadata(file)
doc = Nokogiri::XML(file)
XPATHS.transform_values { |query| doc.xpath(query).text.presence }
.compact
.tap do |metadata|
metadata[:package_dependencies] = extract_dependencies(doc)
metadata[:package_tags] = extract_tags(doc)
metadata[:package_types] = extract_package_types(doc)
end
end
def extract_dependencies(doc)
dependencies = []
doc.xpath(XPATH_DEPENDENCIES).each do |node|
dependencies << extract_dependency(node)
end
doc.xpath(XPATH_DEPENDENCY_GROUPS).each do |group_node|
target_framework = group_node.attr('targetFramework')
group_node.xpath('xmlns:dependency').each do |node|
dependencies << extract_dependency(node).merge(target_framework: target_framework)
end
end
dependencies
end
def extract_dependency(node)
{
name: node.attr('id'),
version: node.attr('version')
}.compact
end
def extract_tags(doc)
tags = doc.xpath(XPATH_TAGS).text
return [] if tags.blank?
tags.split(::Packages::Tag::NUGET_TAGS_SEPARATOR)
end
def extract_package_types(doc)
doc.xpath(XPATH_PACKAGE_TYPES).map { |node| node.attr('name') }.uniq
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Nuget::ExtractMetadataContentService, feature_category: :package_registry do
let(:nuspec_file_content) { fixture_file(nuspec_filepath) }
let(:service) { described_class.new(nuspec_file_content) }
describe '#execute' do
subject { service.execute.payload }
context 'with nuspec file content' do
context 'with dependencies' do
let(:nuspec_filepath) { 'packages/nuget/with_dependencies.nuspec' }
it { is_expected.to have_key(:package_dependencies) }
it 'extracts dependencies' do
dependencies = subject[:package_dependencies]
expect(dependencies).to include(name: 'Moqi', version: '2.5.6')
expect(dependencies).to include(name: 'Castle.Core')
expect(dependencies).to include(name: 'Test.Dependency', version: '2.3.7',
target_framework: '.NETStandard2.0')
expect(dependencies).to include(name: 'Newtonsoft.Json', version: '12.0.3',
target_framework: '.NETStandard2.0')
end
end
context 'with package types' do
let(:nuspec_filepath) { 'packages/nuget/with_package_types.nuspec' }
it { is_expected.to have_key(:package_types) }
it 'extracts package types' do
expect(subject[:package_types]).to include('SymbolsPackage')
end
end
context 'with a nuspec file with metadata' do
let(:nuspec_filepath) { 'packages/nuget/with_metadata.nuspec' }
it { expect(subject[:package_tags].sort).to eq(%w[foo bar test tag1 tag2 tag3 tag4 tag5].sort) }
end
end
context 'with a nuspec file content with metadata' do
let_it_be(:nuspec_filepath) { 'packages/nuget/with_metadata.nuspec' }
it 'returns the correct metadata' do
expected_metadata = {
authors: 'Author Test',
description: 'Description Test',
license_url: 'https://opensource.org/licenses/MIT',
project_url: 'https://gitlab.com/gitlab-org/gitlab',
icon_url: 'https://opensource.org/files/osi_keyhole_300X300_90ppi_0.png'
}
expect(subject.slice(*expected_metadata.keys)).to eq(expected_metadata)
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Nuget
class SearchService < BaseService
include ::Packages::FinderHelper
include Gitlab::Utils::StrongMemoize
include ActiveRecord::ConnectionAdapters::Quoting
MAX_PER_PAGE = 30
MAX_VERSIONS_PER_PACKAGE = 10
PRE_RELEASE_VERSION_MATCHING_TERM = '%-%'
DEFAULT_OPTIONS = {
include_prerelease_versions: true,
per_page: Kaminari.config.default_per_page,
padding: 0
}.freeze
def initialize(current_user, project_or_group, search_term, options = {})
@current_user = current_user
@project_or_group = project_or_group
@search_term = search_term
@options = DEFAULT_OPTIONS.merge(options)
raise ArgumentError, 'negative per_page' if per_page < 0
raise ArgumentError, 'negative padding' if padding < 0
end
def execute
Result.new(
total_count: non_paginated_matching_package_names.count,
results: search_packages
)
end
private
def search_packages
# custom query to get package names and versions as expected from the nuget search api
# See https://gitlab.com/gitlab-org/gitlab/-/merge_requests/24182#technical-notes
# and https://docs.microsoft.com/en-us/nuget/api/search-query-service-resource
subquery_name = :partition_subquery
arel_table = Arel::Table.new(subquery_name)
column_names = Packages::Package.column_names.map do |cn|
"#{subquery_name}.#{quote_column_name(cn)}"
end
# rubocop: disable CodeReuse/ActiveRecord
pkgs = Packages::Package
pkgs = pkgs.with(project_ids_cte.to_arel) if use_project_ids_cte?
pkgs = pkgs.select(column_names.join(','))
.from(package_names_partition, subquery_name)
.where(arel_table[:row_number].lteq(MAX_VERSIONS_PER_PACKAGE))
return pkgs if include_prerelease_versions?
# we can't use pkgs.without_version_like since we have a custom from
pkgs.where.not(arel_table[:version].matches(PRE_RELEASE_VERSION_MATCHING_TERM))
# rubocop: enable CodeReuse/ActiveRecord
end
def package_names_partition
# rubocop: disable CodeReuse/ActiveRecord
table_name = quote_table_name(Packages::Package.table_name)
name_column = "#{table_name}.#{quote_column_name('name')}"
created_at_column = "#{table_name}.#{quote_column_name('created_at')}"
select_sql = "ROW_NUMBER() OVER (PARTITION BY #{name_column} ORDER BY #{created_at_column} DESC) AS row_number, #{table_name}.*"
nuget_packages.select(select_sql)
.with_name(paginated_matching_package_names)
.where(project_id: project_ids)
# rubocop: enable CodeReuse/ActiveRecord
end
def paginated_matching_package_names
pkgs = base_matching_package_names
pkgs.page(0) # we're using a padding
.per(per_page)
.padding(padding)
end
def non_paginated_matching_package_names
# rubocop: disable CodeReuse/ActiveRecord
pkgs = base_matching_package_names
pkgs = pkgs.with(project_ids_cte.to_arel) if use_project_ids_cte?
pkgs
# rubocop: enable CodeReuse/ActiveRecord
end
def base_matching_package_names
# rubocop: disable CodeReuse/ActiveRecord
pkgs = nuget_packages.order_name
.select_distinct_name
.where(project_id: project_ids)
pkgs = pkgs.without_version_like(PRE_RELEASE_VERSION_MATCHING_TERM) unless include_prerelease_versions?
pkgs = pkgs.search_by_name(@search_term) if @search_term.present?
pkgs
# rubocop: enable CodeReuse/ActiveRecord
end
strong_memoize_attr :base_matching_package_names
def nuget_packages
Packages::Package.nuget
.displayable
.has_version
.without_nuget_temporary_name
end
def project_ids_cte
return unless use_project_ids_cte?
query = projects_visible_to_user(@current_user, within_group: @project_or_group)
Gitlab::SQL::CTE.new(:project_ids, query.select(:id))
end
strong_memoize_attr :project_ids_cte
def project_ids
return @project_or_group.id if project?
if use_project_ids_cte?
# rubocop: disable CodeReuse/ActiveRecord
Project.select(:id)
.from(project_ids_cte.table)
# rubocop: enable CodeReuse/ActiveRecord
end
end
def use_project_ids_cte?
group?
end
def project?
@project_or_group.is_a?(::Project)
end
def group?
@project_or_group.is_a?(::Group)
end
def include_prerelease_versions?
@options[:include_prerelease_versions]
end
def padding
@options[:padding]
end
def per_page
[@options[:per_page], MAX_PER_PAGE].min
end
class Result
include ActiveModel::Model
attr_accessor :results, :total_count
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Nuget::SearchService, feature_category: :package_registry do
let_it_be(:user) { create(:user) }
let_it_be(:group) { create(:group) }
let_it_be(:subgroup) { create(:group, parent: group) }
let_it_be(:project) { create(:project, namespace: subgroup) }
let_it_be_with_refind(:package_a) { create(:nuget_package, project: project, name: 'DummyPackageA') }
let_it_be(:packages_b) { create_list(:nuget_package, 5, project: project, name: 'DummyPackageB') }
let_it_be(:packages_c) { create_list(:nuget_package, 5, project: project, name: 'DummyPackageC') }
let_it_be(:package_d) { create(:nuget_package, project: project, name: 'FooBarD') }
let_it_be(:other_package_a) { create(:nuget_package, name: 'DummyPackageA') }
let_it_be(:other_package_a) { create(:nuget_package, name: 'DummyPackageB') }
let(:search_term) { 'ummy' }
let(:per_page) { 5 }
let(:padding) { 0 }
let(:include_prerelease_versions) { true }
let(:options) { { include_prerelease_versions: include_prerelease_versions, per_page: per_page, padding: padding } }
describe '#execute' do
subject { described_class.new(user, target, search_term, options).execute }
shared_examples 'handling all the conditions' do
it { expect_search_results 3, package_a, packages_b, packages_c }
context 'with a smaller per page count' do
let(:per_page) { 2 }
it { expect_search_results 3, package_a, packages_b }
end
context 'with 0 per page count' do
let(:per_page) { 0 }
it { expect_search_results 3, [] }
end
context 'with a negative per page count' do
let(:per_page) { -1 }
it { expect { subject }.to raise_error(ArgumentError, 'negative per_page') }
end
context 'with a padding' do
let(:padding) { 2 }
it { expect_search_results 3, packages_c }
end
context 'with a too big padding' do
let(:padding) { 5 }
it { expect_search_results 3, [] }
end
context 'with a negative padding' do
let(:padding) { -1 }
it { expect { subject }.to raise_error(ArgumentError, 'negative padding') }
end
context 'with search term' do
let(:search_term) { 'umm' }
it { expect_search_results 3, package_a, packages_b, packages_c }
end
context 'with nil search term' do
let(:search_term) { nil }
it { expect_search_results 4, package_a, packages_b, packages_c, package_d }
end
context 'with empty search term' do
let(:search_term) { '' }
it { expect_search_results 4, package_a, packages_b, packages_c, package_d }
end
context 'with non-displayable packages' do
let(:search_term) { '' }
before do
package_a.update_column(:status, 1)
end
it { expect_search_results 3, packages_b, packages_c, package_d }
end
context 'with prefix search term' do
let(:search_term) { 'dummy' }
it { expect_search_results 3, package_a, packages_b, packages_c }
end
context 'with suffix search term' do
let(:search_term) { 'packagec' }
it { expect_search_results 1, packages_c }
end
context 'with pre release packages' do
let_it_be(:package_e) { create(:nuget_package, project: project, name: 'DummyPackageE', version: '3.2.1-alpha') }
context 'including them' do
it { expect_search_results 4, package_a, packages_b, packages_c, package_e }
end
context 'excluding them' do
let(:include_prerelease_versions) { false }
it { expect_search_results 3, package_a, packages_b, packages_c }
context 'when mixed with release versions' do
let_it_be(:package_e_release) { create(:nuget_package, project: project, name: 'DummyPackageE', version: '3.2.1') }
it { expect_search_results 4, package_a, packages_b, packages_c, package_e_release }
end
end
end
end
context 'with project' do
let(:target) { project }
before do
project.add_developer(user)
end
it_behaves_like 'handling all the conditions'
end
context 'with subgroup' do
let(:target) { subgroup }
before do
subgroup.add_developer(user)
end
it_behaves_like 'handling all the conditions'
end
context 'with group' do
let(:target) { group }
before do
group.add_developer(user)
end
it_behaves_like 'handling all the conditions'
end
def expect_search_results(total_count, *results)
search = subject
expect(search.total_count).to eq total_count
expect(search.results).to match_array(Array.wrap(results).flatten)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Nuget
class SyncMetadatumService
include Gitlab::Utils::StrongMemoize
def initialize(package, metadata)
@package = package
@metadata = metadata
end
def execute
if blank_metadata?
metadatum.destroy! if metadatum.persisted?
else
metadatum.update!(
authors: authors,
description: description,
license_url: license_url,
project_url: project_url,
icon_url: icon_url
)
end
end
private
attr_reader :package, :metadata
def metadatum
package.nuget_metadatum || package.build_nuget_metadatum
end
strong_memoize_attr :metadatum
def blank_metadata?
[authors, description, project_url, license_url, icon_url].all?(&:blank?)
end
def authors
truncate_value(:authors, ::Packages::Nuget::Metadatum::MAX_AUTHORS_LENGTH)
end
strong_memoize_attr :authors
def description
truncate_value(:description, ::Packages::Nuget::Metadatum::MAX_DESCRIPTION_LENGTH)
end
strong_memoize_attr :description
def project_url
metadata[:project_url]
end
def license_url
metadata[:license_url]
end
def icon_url
metadata[:icon_url]
end
def truncate_value(field, max_length)
return unless metadata[field]
if metadata[field].size > max_length
log_info("#{field.capitalize} is too long (maximum is #{max_length} characters)", field)
end
metadata[field].truncate(max_length)
end
def log_info(message, field)
Gitlab::AppLogger.info(
class: self.class.name,
message: message,
package_id: package.id,
project_id: package.project_id,
field => metadata[field]
)
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Nuget::SyncMetadatumService, feature_category: :package_registry do
let_it_be(:package, reload: true) { create(:nuget_package) }
let_it_be(:metadata) do
{
authors: 'Package authors',
description: 'Package description',
project_url: 'https://test.org/test',
license_url: 'https://test.org/MIT',
icon_url: 'https://test.org/icon.png'
}
end
let(:service) { described_class.new(package, metadata) }
let(:nuget_metadatum) { package.nuget_metadatum }
describe '#execute' do
subject { service.execute }
RSpec.shared_examples 'saving metadatum attributes' do
it 'saves nuget metadatum' do
subject
metadata.each do |attribute, expected_value|
expect(nuget_metadatum.send(attribute)).to eq(expected_value)
end
end
end
it 'creates a nuget metadatum' do
expect { subject }
.to change { package.nuget_metadatum.present? }.from(false).to(true)
end
it_behaves_like 'saving metadatum attributes'
context 'with exisiting nuget metadatum' do
let_it_be(:package) { create(:nuget_package, :with_metadatum) }
it 'does not create a nuget metadatum' do
expect { subject }.to change { ::Packages::Nuget::Metadatum.count }.by(0)
end
it_behaves_like 'saving metadatum attributes'
context 'with empty metadata' do
let_it_be(:metadata) { {} }
it 'destroys the nuget metadatum' do
expect { subject }
.to change { package.reload.nuget_metadatum.present? }.from(true).to(false)
end
end
end
context 'with metadata containing only authors and description' do
let_it_be(:metadata) { { authors: 'Package authors 2', description: 'Package description 2' } }
it 'updates the nuget metadatum' do
subject
expect(nuget_metadatum.authors).to eq('Package authors 2')
expect(nuget_metadatum.description).to eq('Package description 2')
end
end
context 'with too long metadata' do
let(:metadata) { super().merge(authors: 'a' * 260, description: 'a' * 4010) }
let(:max_authors_length) { ::Packages::Nuget::Metadatum::MAX_AUTHORS_LENGTH }
let(:max_description_length) { ::Packages::Nuget::Metadatum::MAX_DESCRIPTION_LENGTH }
it 'truncates authors and description to the maximum length and logs its info' do
%i[authors description].each do |field|
expect(Gitlab::AppLogger).to receive(:info).with(
class: described_class.name,
package_id: package.id,
project_id: package.project_id,
message: "#{field.capitalize} is too long (maximum is #{send("max_#{field}_length")} characters)",
field => metadata[field]
)
end
subject
expect(nuget_metadatum.authors.size).to eq(max_authors_length)
expect(nuget_metadatum.description.size).to eq(max_description_length)
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Nuget
class OdataPackageEntryService
include API::Helpers::RelatedResourcesHelpers
def initialize(project, params)
@project = project
@params = params
end
def execute
ServiceResponse.success(payload: package_entry)
end
private
attr_reader :project, :params
def package_entry
<<-XML.squish
<entry xmlns='http://www.w3.org/2005/Atom' xmlns:d='http://schemas.microsoft.com/ado/2007/08/dataservices' xmlns:georss='http://www.georss.org/georss' xmlns:gml='http://www.opengis.net/gml' xmlns:m='http://schemas.microsoft.com/ado/2007/08/dataservices/metadata' xml:base="#{xml_base}">
<id>#{id_url}</id>
<category term='V2FeedPackage' scheme='http://schemas.microsoft.com/ado/2007/08/dataservices/scheme'/>
<title type='text'>#{params[:package_name]}</title>
<content type='application/zip' src="#{download_url}"/>
<m:properties>
<d:Version>#{params[:package_version]}</d:Version>
</m:properties>
</entry>
XML
end
def id_url
expose_url "#{api_v4_projects_packages_nuget_v2_path(id: project.id)}" \
"/Packages(Id='#{params[:package_name]}',Version='#{params[:package_version]}')"
end
def download_url
if params[:package_version].present?
expose_url api_v4_projects_packages_nuget_download_package_name_package_version_package_filename_path(
{
id: project.id,
package_name: params[:package_name],
package_version: params[:package_version],
package_filename: file_name
},
true
)
else
xml_base
end
end
def xml_base
expose_url api_v4_projects_packages_nuget_v2_path(id: project.id)
end
def file_name
"#{params[:package_name]}.#{params[:package_version]}.nupkg"
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Nuget::OdataPackageEntryService, feature_category: :package_registry do
include GrapePathHelpers::NamedRouteMatcher
let_it_be(:project) { build_stubbed(:project) }
let_it_be(:params) { { package_name: 'dummy', package_version: '1.0.0' } }
let(:doc) { Nokogiri::XML(subject.payload) }
subject { described_class.new(project, params).execute }
describe '#execute' do
shared_examples 'returning a package entry with the correct attributes' do |pkg_version = ''|
it 'returns a package entry with the correct attributes' do
expect(doc.root.name).to eq('entry')
expect(doc_node('id').text).to include(
id_url(project.id, params[:package_name], pkg_version)
)
expect(doc_node('title').text).to eq(params[:package_name])
expect(doc_node('content').attr('src')).to include(
content_url(project.id, params[:package_name], pkg_version)
)
expect(doc_node('Version').text).to eq(pkg_version)
end
end
context 'when package_version is present' do
it 'returns a success ServiceResponse' do
expect(subject).to be_success
end
it_behaves_like 'returning a package entry with the correct attributes', '1.0.0'
end
context 'when package_version is not present' do
let(:params) { { package_name: 'dummy', package_version: nil } }
it 'returns a success ServiceResponse' do
expect(subject).to be_success
end
it_behaves_like 'returning a package entry with the correct attributes'
end
end
def doc_node(name)
doc.css('*').detect { |el| el.name == name }
end
def id_url(id, package_name, package_version)
"api/v4/projects/#{id}/packages/nuget/v2/Packages(Id='#{package_name}',Version='#{package_version}')"
end
def content_url(id, package_name, package_version)
if package_version.present?
filename = "#{package_name}.#{package_version}.nupkg"
api_v4_projects_packages_nuget_download_package_name_package_version_package_filename_path(
{ id: id, package_name: package_name, package_version: package_version, package_filename: filename }, true
)
else
api_v4_projects_packages_nuget_v2_path(id: id)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Nuget
class UpdatePackageFromMetadataService
include Gitlab::Utils::StrongMemoize
include ExclusiveLeaseGuard
# used by ExclusiveLeaseGuard
DEFAULT_LEASE_TIMEOUT = 1.hour.to_i.freeze
SYMBOL_PACKAGE_IDENTIFIER = 'SymbolsPackage'
INVALID_METADATA_ERROR_MESSAGE = 'package name, version, authors and/or description not found in metadata'
INVALID_METADATA_ERROR_SYMBOL_MESSAGE = 'package name, version and/or description not found in metadata'
MISSING_MATCHING_PACKAGE_ERROR_MESSAGE = 'symbol package is invalid, matching package does not exist'
InvalidMetadataError = ZipError = Class.new(StandardError)
def initialize(package_file, package_zip_file)
@package_file = package_file
@package_zip_file = package_zip_file
end
def execute
unless valid_metadata?
error_message = symbol_package? ? INVALID_METADATA_ERROR_SYMBOL_MESSAGE : INVALID_METADATA_ERROR_MESSAGE
raise InvalidMetadataError, error_message
end
try_obtain_lease do
@package_file.transaction do
process_package_update
end
end
rescue ActiveRecord::RecordInvalid => e
raise InvalidMetadataError, e.message
rescue Zip::Error
raise ZipError, 'Could not open the .nupkg file'
end
private
def process_package_update
package_to_destroy = nil
target_package = @package_file.package
if existing_package
package_to_destroy = @package_file.package
target_package = existing_package
else
if symbol_package?
raise InvalidMetadataError, MISSING_MATCHING_PACKAGE_ERROR_MESSAGE
end
update_linked_package
end
build_infos = package_to_destroy&.build_infos || []
update_package(target_package, build_infos)
create_symbol_files
::Packages::UpdatePackageFileService.new(@package_file, package_id: target_package.id, file_name: package_filename)
.execute
package_to_destroy&.destroy!
end
def update_package(package, build_infos)
return if symbol_package?
::Packages::Nuget::SyncMetadatumService
.new(package, metadata.slice(:authors, :description, :project_url, :license_url, :icon_url))
.execute
::Packages::UpdateTagsService
.new(package, package_tags)
.execute
package.build_infos << build_infos if build_infos.any?
rescue StandardError => e
raise InvalidMetadataError, e.message
end
def create_symbol_files
return unless symbol_package?
::Packages::Nuget::Symbols::CreateSymbolFilesService
.new(existing_package, @package_zip_file)
.execute
end
def valid_metadata?
fields = [package_name, package_version, package_description]
fields << package_authors unless symbol_package?
fields.all?(&:present?)
end
def update_linked_package
@package_file.package.update!(
name: package_name,
version: package_version,
status: :default
)
::Packages::Nuget::CreateDependencyService.new(@package_file.package, package_dependencies)
.execute
@package_file.package
end
def existing_package
::Packages::Nuget::PackageFinder
.new(
nil,
@package_file.project,
package_name: package_name,
package_version: package_version
)
.execute
.first
end
strong_memoize_attr :existing_package
def package_name
metadata[:package_name]
end
def package_version
metadata[:package_version]
end
def package_dependencies
metadata.fetch(:package_dependencies, [])
end
def package_tags
metadata.fetch(:package_tags, [])
end
def package_types
metadata.fetch(:package_types, [])
end
def package_authors
metadata[:authors]
end
def package_description
metadata[:description]
end
def symbol_package?
package_types.include?(SYMBOL_PACKAGE_IDENTIFIER)
end
strong_memoize_attr :symbol_package?
def metadata
::Packages::Nuget::MetadataExtractionService.new(@package_zip_file).execute.payload
end
strong_memoize_attr :metadata
def package_filename
"#{package_name.downcase}.#{package_version.downcase}.#{symbol_package? ? 'snupkg' : 'nupkg'}"
end
# used by ExclusiveLeaseGuard
def lease_key
package_id = existing_package ? existing_package.id : @package_file.package_id
"packages:nuget:update_package_from_metadata_service:package:#{package_id}"
end
# used by ExclusiveLeaseGuard
def lease_timeout
DEFAULT_LEASE_TIMEOUT
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Nuget::UpdatePackageFromMetadataService, :clean_gitlab_redis_shared_state, feature_category: :package_registry do
include ExclusiveLeaseHelpers
let!(:package) { create(:nuget_package, :processing, :with_symbol_package, :with_build) }
let(:package_file) { package.package_files.first }
let(:package_zip_file) { Zip::File.new(package_file.file) }
let(:service) { described_class.new(package_file, package_zip_file) }
let(:package_name) { 'DummyProject.DummyPackage' }
let(:package_version) { '1.0.0' }
let(:package_file_name) { 'dummyproject.dummypackage.1.0.0.nupkg' }
shared_examples 'raising an' do |error_class, with_message:|
it "raises an #{error_class}" do
expect { subject }.to raise_error(error_class, with_message)
end
end
describe '#execute' do
using RSpec::Parameterized::TableSyntax
subject { service.execute }
shared_examples 'taking the lease' do
before do
allow(service).to receive(:lease_release?).and_return(false)
end
it 'takes the lease' do
expect(service).to receive(:try_obtain_lease).and_call_original
subject
expect(service.exclusive_lease.exists?).to be_truthy
end
end
shared_examples 'not updating the package if the lease is taken' do
context 'without obtaining the exclusive lease' do
let(:lease_key) { "packages:nuget:update_package_from_metadata_service:package:#{package_id}" }
let(:metadata) { { package_name: package_name, package_version: package_version, authors: 'author1, author2', description: 'test description' } }
let(:package_from_package_file) { package_file.package }
before do
stub_exclusive_lease_taken(lease_key, timeout: 1.hour)
# to allow the above stub, we need to stub the metadata function as the
# original implementation will try to get an exclusive lease on the
# file in object storage
allow(service).to receive(:metadata).and_return(metadata)
end
it 'does not update the package', :aggregate_failures do
expect(service).to receive(:try_obtain_lease).and_call_original
expect { subject }
.to change { ::Packages::Package.count }.by(0)
.and change { Packages::DependencyLink.count }.by(0)
expect(package_file.reload.file_name).not_to eq(package_file_name)
expect(package_file.package).to be_processing
expect(package_file.package.reload.name).not_to eq(package_name)
expect(package_file.package.version).not_to eq(package_version)
end
end
end
context 'with no existing package' do
let(:package_id) { package.id }
it 'updates package and package file and creates metadatum', :aggregate_failures do
expect { subject }
.to not_change { ::Packages::Package.count }
.and change { Packages::Dependency.count }.by(1)
.and change { Packages::DependencyLink.count }.by(1)
.and change { ::Packages::Nuget::Metadatum.count }.by(1)
expect(package.reload.name).to eq(package_name)
expect(package.version).to eq(package_version)
expect(package).to be_default
expect(package_file.reload.file_name).to eq(package_file_name)
# hard reset needed to properly reload package_file.file
expect(Packages::PackageFile.find(package_file.id).file.size).not_to eq 0
end
it_behaves_like 'taking the lease'
it_behaves_like 'not updating the package if the lease is taken'
end
context 'with existing package' do
let!(:existing_package) { create(:nuget_package, project: package.project, name: package_name, version: package_version) }
let(:package_id) { existing_package.id }
it 'link existing package and updates package file', :aggregate_failures do
expect(service).to receive(:try_obtain_lease).and_call_original
expect { subject }
.to change { ::Packages::Package.count }.by(-1)
.and change { Packages::Dependency.count }.by(0)
.and change { Packages::DependencyLink.count }.by(0)
.and change { Packages::Nuget::DependencyLinkMetadatum.count }.by(0)
.and change { ::Packages::Nuget::Metadatum.count }.by(1)
.and change { existing_package.build_infos.count }.by(1)
expect(package_file.reload.file_name).to eq(package_file_name)
expect(package_file.package).to eq(existing_package)
end
it_behaves_like 'taking the lease'
it_behaves_like 'not updating the package if the lease is taken'
context 'marked as pending_destruction' do
before do
existing_package.pending_destruction!
end
it 'reuses the processing package', :aggregate_failures do
expect { subject }
.to not_change { ::Packages::Package.count }
.and change { Packages::Dependency.count }.by(1)
.and change { Packages::DependencyLink.count }.by(1)
.and change { ::Packages::Nuget::Metadatum.count }.by(1)
end
end
end
context 'with a nuspec file with metadata' do
let(:nuspec_filepath) { 'packages/nuget/with_metadata.nuspec' }
let(:expected_tags) { %w[foo bar test tag1 tag2 tag3 tag4 tag5] }
before do
allow_next_instance_of(Packages::Nuget::MetadataExtractionService) do |service|
allow(service)
.to receive(:nuspec_file_content).and_return(fixture_file(nuspec_filepath))
end
end
it 'creates tags' do
expect(service).to receive(:try_obtain_lease).and_call_original
expect { subject }.to change { ::Packages::Tag.count }.by(8)
expect(package.reload.tags.map(&:name)).to contain_exactly(*expected_tags)
end
context 'with existing package and tags' do
let!(:existing_package) { create(:nuget_package, project: package.project, name: 'DummyProject.WithMetadata', version: '1.2.3') }
let!(:tag1) { create(:packages_tag, package: existing_package, name: 'tag1') }
let!(:tag2) { create(:packages_tag, package: existing_package, name: 'tag2') }
let!(:tag3) { create(:packages_tag, package: existing_package, name: 'tag_not_in_metadata') }
it 'creates tags and deletes those not in metadata' do
expect(service).to receive(:try_obtain_lease).and_call_original
expect { subject }.to change { ::Packages::Tag.count }.by(5)
expect(existing_package.tags.map(&:name)).to contain_exactly(*expected_tags)
end
end
it 'creates nuget metadatum', :aggregate_failures do
expect { subject }
.to not_change { ::Packages::Package.count }
.and change { ::Packages::Nuget::Metadatum.count }.by(1)
metadatum = package_file.reload.package.nuget_metadatum
expect(metadatum.authors).to eq('Author Test')
expect(metadatum.description).to eq('Description Test')
expect(metadatum.license_url).to eq('https://opensource.org/licenses/MIT')
expect(metadatum.project_url).to eq('https://gitlab.com/gitlab-org/gitlab')
expect(metadatum.icon_url).to eq('https://opensource.org/files/osi_keyhole_300X300_90ppi_0.png')
end
context 'with too long url' do
let_it_be(:too_long_url) { "http://localhost/#{'bananas' * 50}" }
let(:metadata) { { package_name: package_name, package_version: package_version, authors: 'Author Test', description: 'Description Test', license_url: too_long_url } }
before do
allow(service).to receive(:metadata).and_return(metadata)
end
it_behaves_like 'raising an', described_class::InvalidMetadataError, with_message: /Validation failed: License url is too long/
end
context 'without authors or description' do
%i[authors description].each do |property|
context "for #{property}" do
let(:metadata) { { package_name: package_name, package_version: package_version, property => nil } }
before do
allow(service).to receive(:metadata).and_return(metadata)
end
it_behaves_like 'raising an', described_class::InvalidMetadataError, with_message: described_class::INVALID_METADATA_ERROR_MESSAGE
end
end
end
end
context 'with nuspec file with dependencies' do
let(:nuspec_filepath) { 'packages/nuget/with_dependencies.nuspec' }
let(:package_name) { 'Test.Package' }
let(:package_version) { '3.5.2' }
let(:package_file_name) { 'test.package.3.5.2.nupkg' }
before do
allow_next_instance_of(Packages::Nuget::MetadataExtractionService) do |service|
allow(service)
.to receive(:nuspec_file_content).and_return(fixture_file(nuspec_filepath))
end
end
it 'updates package and package file', :aggregate_failures do
expect { subject }
.to not_change { ::Packages::Package.count }
.and change { Packages::Dependency.count }.by(4)
.and change { Packages::DependencyLink.count }.by(4)
.and change { Packages::Nuget::DependencyLinkMetadatum.count }.by(2)
expect(package.reload.name).to eq(package_name)
expect(package.version).to eq(package_version)
expect(package).to be_default
expect(package_file.reload.file_name).to eq(package_file_name)
# hard reset needed to properly reload package_file.file
expect(Packages::PackageFile.find(package_file.id).file.size).not_to eq 0
end
end
context 'with package file not containing a nuspec file' do
before do
allow_next_instance_of(Zip::File) do |file|
allow(file).to receive(:glob).and_return([])
end
end
it_behaves_like 'raising an', ::Packages::Nuget::ExtractMetadataFileService::ExtractionError, with_message: 'nuspec file not found'
end
context 'with a symbol package' do
let(:package_file) { package.package_files.last }
let(:package_file_name) { 'dummyproject.dummypackage.1.0.0.snupkg' }
context 'with no existing package' do
let(:package_id) { package.id }
it_behaves_like 'raising an', described_class::InvalidMetadataError, with_message: described_class::MISSING_MATCHING_PACKAGE_ERROR_MESSAGE
end
context 'with existing package' do
let!(:existing_package) { create(:nuget_package, project: package.project, name: package_name, version: package_version) }
let(:package_id) { existing_package.id }
let(:package_zip_file) do
Zip::File.open(package_file.file.path) do |zipfile|
zipfile.add('package.pdb', expand_fixture_path('packages/nuget/symbol/package.pdb'))
zipfile
end
end
it 'link existing package and updates package file', :aggregate_failures do
expect(service).to receive(:try_obtain_lease).and_call_original
expect(::Packages::Nuget::SyncMetadatumService).not_to receive(:new)
expect(::Packages::UpdateTagsService).not_to receive(:new)
expect_next_instance_of(Packages::Nuget::Symbols::CreateSymbolFilesService, existing_package, package_zip_file) do |service|
expect(service).to receive(:execute).and_call_original
end
expect { subject }
.to change { ::Packages::Package.count }.by(-1)
.and change { Packages::Dependency.count }.by(0)
.and change { Packages::DependencyLink.count }.by(0)
.and change { Packages::Nuget::DependencyLinkMetadatum.count }.by(0)
.and change { ::Packages::Nuget::Metadatum.count }.by(0)
.and change { existing_package.nuget_symbols.count }.by(1)
expect(package_file.reload.file_name).to eq(package_file_name)
expect(package_file.package).to eq(existing_package)
end
it_behaves_like 'taking the lease'
it_behaves_like 'not updating the package if the lease is taken'
end
end
context 'with an invalid package name' do
invalid_name_error_msg = 'Validation failed: Name is invalid'
where(:invalid_name, :error_message) do
'' | described_class::INVALID_METADATA_ERROR_MESSAGE
'My/package' | invalid_name_error_msg
'../../../my_package' | invalid_name_error_msg
'%2e%2e%2fmy_package' | invalid_name_error_msg
end
with_them do
before do
allow(service).to receive(:package_name).and_return(invalid_name)
end
it_behaves_like 'raising an', described_class::InvalidMetadataError, with_message: params[:error_message]
end
end
context 'with an invalid package version' do
invalid_version_error_msg = 'Validation failed: Version is invalid'
where(:invalid_version, :error_message) do
'' | described_class::INVALID_METADATA_ERROR_MESSAGE
'555' | invalid_version_error_msg
'1./2.3' | invalid_version_error_msg
'../../../../../1.2.3' | invalid_version_error_msg
'%2e%2e%2f1.2.3' | invalid_version_error_msg
end
with_them do
before do
allow(service).to receive(:package_version).and_return(invalid_version)
end
it_behaves_like 'raising an', described_class::InvalidMetadataError, with_message: params[:error_message]
end
end
context 'with an invalid zip file' do
before do
allow_next_instance_of(::Packages::Nuget::MetadataExtractionService) do |instance|
allow(instance).to receive(:execute).and_raise(Zip::Error)
end
end
it_behaves_like 'raising an', described_class::ZipError, with_message: 'Could not open the .nupkg file'
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Nuget
class CheckDuplicatesService < BaseService
include Gitlab::Utils::StrongMemoize
ExtractionError = Class.new(StandardError)
def execute
return ServiceResponse.success if package_settings_allow_duplicates? || !target_package_is_duplicate?
ServiceResponse.error(
message: 'A package with the same name and version already exists',
reason: :conflict
)
rescue ExtractionError => e
ServiceResponse.error(message: e.message, reason: :bad_request)
end
private
def package_settings_allow_duplicates?
package_settings.nuget_duplicates_allowed? || package_settings.class.duplicates_allowed?(existing_package)
end
def target_package_is_duplicate?
existing_package.name.casecmp(metadata[:package_name]) == 0 &&
(existing_package.version.casecmp(metadata[:package_version]) == 0 ||
existing_package.normalized_nuget_version&.casecmp(metadata[:package_version]) == 0)
end
def package_settings
project.namespace.package_settings
end
strong_memoize_attr :package_settings
def existing_package
::Packages::Nuget::PackageFinder
.new(
current_user,
project,
package_name: metadata[:package_name],
package_version: metadata[:package_version]
)
.execute
.first
end
strong_memoize_attr :existing_package
def metadata
if params[:remote_url].present?
::Packages::Nuget::ExtractMetadataContentService
.new(nuspec_file_content)
.execute
.payload
else # to cover the case when package file is on disk not in object storage
Zip::InputStream.open(params[:file]) do |zip|
::Packages::Nuget::MetadataExtractionService
.new(zip)
.execute
.payload
end
end
end
strong_memoize_attr :metadata
def nuspec_file_content
::Packages::Nuget::ExtractRemoteMetadataFileService
.new(params[:remote_url])
.execute
.payload
rescue ::Packages::Nuget::ExtractRemoteMetadataFileService::ExtractionError => e
raise ExtractionError, e.message
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Nuget::CheckDuplicatesService, feature_category: :package_registry do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
let_it_be(:file_name) { 'package.nupkg' }
let(:params) do
{
file_name: file_name,
file: File.open(expand_fixture_path('packages/nuget/package.nupkg'))
}
end
let(:service) { described_class.new(project, user, params) }
describe '#execute' do
subject(:execute) { service.execute }
shared_examples 'returning error' do |reason:, message:|
it 'returns an error' do
response = execute
expect(response.status).to eq(:error)
expect(response.reason).to eq(reason)
expect(response.message).to eq(message)
end
end
shared_examples 'returning success' do
it 'returns success' do
response = execute
expect(response.status).to eq(:success)
end
end
shared_examples 'handling duplicates disallowed when package exists' do
it_behaves_like 'returning error', reason: :conflict,
message: 'A package with the same name and version already exists'
context 'with nuget_duplicate_exception_regex' do
before do
package_settings.update_column(:nuget_duplicate_exception_regex, ".*#{existing_package.name.last(3)}.*")
end
it_behaves_like 'returning success'
end
end
context 'with existing package' do
let_it_be(:existing_package) { create(:nuget_package, :with_metadatum, project: project, version: '1.7.15.0') }
let_it_be(:metadata) do
{
package_name: existing_package.name,
package_version: existing_package.version,
authors: 'authors',
description: 'description'
}
end
context 'when nuget duplicates are allowed' do
before do
allow_next_instance_of(Namespace::PackageSetting) do |instance|
allow(instance).to receive(:nuget_duplicates_allowed?).and_return(true)
end
end
it_behaves_like 'returning success'
end
context 'when nuget duplicates are not allowed' do
let!(:package_settings) do
create(:namespace_package_setting, :group, namespace: project.namespace, nuget_duplicates_allowed: false)
end
context 'when package file is in object storage' do
let(:params) { super().merge(remote_url: 'https://example.com') }
before do
allow_next_instance_of(::Packages::Nuget::ExtractRemoteMetadataFileService) do |instance|
allow(instance).to receive(:execute)
.and_return(ServiceResponse.success(payload: Nokogiri::XML::Document.new))
end
allow_next_instance_of(::Packages::Nuget::ExtractMetadataContentService) do |instance|
allow(instance).to receive(:execute).and_return(ServiceResponse.success(payload: metadata))
end
end
it_behaves_like 'handling duplicates disallowed when package exists'
context 'when ExtractRemoteMetadataFileService raises ExtractionError' do
before do
allow_next_instance_of(::Packages::Nuget::ExtractRemoteMetadataFileService) do |instance|
allow(instance).to receive(:execute).and_raise(
::Packages::Nuget::ExtractRemoteMetadataFileService::ExtractionError, 'nuspec file not found'
)
end
end
it_behaves_like 'returning error', reason: :bad_request, message: 'nuspec file not found'
end
context 'when version is normalized' do
let(:metadata) { super().merge(package_version: '1.7.15') }
it_behaves_like 'handling duplicates disallowed when package exists'
end
end
context 'when package file is on disk' do
before do
allow_next_instance_of(::Packages::Nuget::MetadataExtractionService) do |instance|
allow(instance).to receive(:execute).and_return(ServiceResponse.success(payload: metadata))
end
end
it_behaves_like 'handling duplicates disallowed when package exists'
end
end
end
context 'with non existing package' do
let_it_be(:metadata) do
{ package_name: 'foo', package_version: '1.0.0', authors: 'author', description: 'description' }
end
before do
allow_next_instance_of(::Packages::Nuget::MetadataExtractionService) do |instance|
allow(instance).to receive(:execute).and_return(ServiceResponse.success(payload: metadata))
end
end
context 'when nuget duplicates are allowed' do
let_it_be(:package_settings) do
create(:namespace_package_setting, :group, namespace: project.namespace, nuget_duplicates_allowed: true)
end
it_behaves_like 'returning success'
end
context 'when nuget duplicates are not allowed' do
let_it_be(:package_settings) do
create(:namespace_package_setting, :group, namespace: project.namespace, nuget_duplicates_allowed: false)
end
it_behaves_like 'returning success'
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Nuget
class ProcessPackageFileService
ExtractionError = Class.new(StandardError)
def initialize(package_file)
@package_file = package_file
end
def execute
raise ExtractionError, 'invalid package file' unless valid_package_file?
with_zip_file do |zip_file|
::Packages::Nuget::UpdatePackageFromMetadataService.new(package_file, zip_file).execute
end
end
private
attr_reader :package_file
def valid_package_file?
package_file && package_file.package&.nuget? && !package_file.file.empty_size?
end
def with_zip_file(&block)
package_file.file.use_open_file(unlink_early: false) do |open_file|
Zip::File.open(open_file.file_path, &block) # rubocop: disable Performance/Rubyzip
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Nuget::ProcessPackageFileService, feature_category: :package_registry do
let_it_be(:package_file) { build(:package_file, :nuget) }
let(:service) { described_class.new(package_file) }
describe '#execute' do
subject { service.execute }
shared_examples 'raises an error' do |error_message|
it { expect { subject }.to raise_error(described_class::ExtractionError, error_message) }
end
context 'with valid package file' do
it 'calls the UpdatePackageFromMetadataService' do
expect_next_instance_of(Packages::Nuget::UpdatePackageFromMetadataService, package_file,
instance_of(Zip::File)) do |service|
expect(service).to receive(:execute)
end
subject
end
end
context 'with invalid package file' do
let(:package_file) { nil }
it_behaves_like 'raises an error', 'invalid package file'
end
context 'when linked to a non nuget package' do
before do
package_file.package.maven!
end
it_behaves_like 'raises an error', 'invalid package file'
end
context 'with a 0 byte package file' do
before do
allow_next_instance_of(Packages::PackageFileUploader) do |instance|
allow(instance).to receive(:size).and_return(0)
end
end
it_behaves_like 'raises an error', 'invalid package file'
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Nuget
class CreateDependencyService < BaseService
def initialize(package, dependencies = [])
@package = package
@dependencies = dependencies
end
def execute
return if @dependencies.empty?
@package.transaction do
create_dependency_links
create_dependency_link_metadata
end
end
private
def create_dependency_links
::Packages::CreateDependencyService
.new(@package, dependencies_for_create_dependency_service)
.execute
end
def create_dependency_link_metadata
inserted_links = ::Packages::DependencyLink.preload_dependency
.for_package(@package)
return if inserted_links.empty?
rows = inserted_links.map do |dependency_link|
raw_dependency = raw_dependency_for(dependency_link.dependency)
next if raw_dependency[:target_framework].blank?
{
dependency_link_id: dependency_link.id,
target_framework: raw_dependency[:target_framework]
}
end
::ApplicationRecord.legacy_bulk_insert(::Packages::Nuget::DependencyLinkMetadatum.table_name, rows.compact) # rubocop:disable Gitlab/BulkInsert
end
def raw_dependency_for(dependency)
name = dependency.name
version = dependency.version_pattern.presence
@dependencies.find do |raw_dependency|
raw_dependency[:name] == name && raw_dependency[:version] == version
end
end
def dependencies_for_create_dependency_service
names_and_versions = @dependencies.to_h do |dependency|
[dependency[:name], version_or_empty_string(dependency[:version])]
end
{ 'dependencies' => names_and_versions }
end
def version_or_empty_string(version)
return '' if version.blank?
version
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Nuget::CreateDependencyService, feature_category: :package_registry do
let_it_be(:package, reload: true) { create(:nuget_package) }
describe '#execute' do
RSpec.shared_examples 'creating dependencies, links and nuget metadata for' do |expected_dependency_names, dependency_count, dependency_link_count|
let(:dependencies_with_metadata) { dependencies.select { |dep| dep[:target_framework].present? } }
it 'creates dependencies, links and nuget metadata' do
expect { subject }
.to change { Packages::Dependency.count }.by(dependency_count)
.and change { Packages::DependencyLink.count }.by(dependency_link_count)
.and change { Packages::Nuget::DependencyLinkMetadatum.count }.by(dependencies_with_metadata.size)
expect(expected_dependency_names).to contain_exactly(*dependency_names)
expect(package.dependency_links.map(&:dependency_type).uniq).to contain_exactly('dependencies')
dependencies_with_metadata.each do |dependency|
name = dependency[:name]
version_pattern = service.send(:version_or_empty_string, dependency[:version])
metadatum = package.dependency_links.joins(:dependency)
.find_by(packages_dependencies: { name: name, version_pattern: version_pattern })
.nuget_metadatum
expect(metadatum.target_framework).to eq dependency[:target_framework]
end
end
end
let_it_be(:dependencies) do
[
{ name: 'Moqi', version: '2.5.6' },
{ name: 'Castle.Core' },
{ name: 'Test.Dependency', version: '2.3.7', target_framework: '.NETStandard2.0' },
{ name: 'Newtonsoft.Json', version: '12.0.3', target_framework: '.NETStandard2.0' }
]
end
let(:dependency_names) { package.dependency_links.flat_map(&:dependency).map(&:name) }
let(:service) { described_class.new(package, dependencies) }
subject { service.execute }
it_behaves_like 'creating dependencies, links and nuget metadata for', %w[Castle.Core Moqi Newtonsoft.Json Test.Dependency], 4, 4
context 'with existing dependencies' do
let_it_be(:exisiting_dependency) { create(:packages_dependency, name: 'Moqi', version_pattern: '2.5.6') }
it_behaves_like 'creating dependencies, links and nuget metadata for', %w[Castle.Core Moqi Newtonsoft.Json Test.Dependency], 3, 4
end
context 'with dependencies with no target framework' do
let_it_be(:dependencies) do
[
{ name: 'Moqi', version: '2.5.6' },
{ name: 'Castle.Core' },
{ name: 'Test.Dependency', version: '2.3.7' },
{ name: 'Newtonsoft.Json', version: '12.0.3' }
]
end
it_behaves_like 'creating dependencies, links and nuget metadata for', %w[Castle.Core Moqi Newtonsoft.Json Test.Dependency], 4, 4
end
context 'with empty dependencies' do
let_it_be(:dependencies) { [] }
it 'is a no op' do
expect(service).not_to receive(:create_dependency_links)
expect(service).not_to receive(:create_dependency_link_metadata)
subject
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Nuget
module Symbols
class ExtractSignatureAndChecksumService
include Gitlab::Utils::StrongMemoize
# More information about the GUID format can be found here:
# https://github.com/dotnet/symstore/blob/main/docs/specs/SSQP_Key_Conventions.md#key-formatting-basic-rules
GUID_START_INDEX = 7
GUID_END_INDEX = 26
SIGNATURE_LENGTH = 16
TWENTY_ZEROED_BYTES = "\u0000" * 20
GUID_PARTS_LENGTHS = [4, 2, 2, 8].freeze
GUID_AGE_PART = 'FFFFFFFF'
TWO_CHARACTER_HEX_REGEX = /\h{2}/
GUID_CHUNK_SIZE = 256.bytes
SHA_CHUNK_SIZE = 16.kilobytes
# The extraction of the signature in this service is based on the following documentation:
# https://github.com/dotnet/symstore/blob/main/docs/specs/SSQP_Key_Conventions.md#portable-pdb-signature
def initialize(file)
@file = file
end
def execute
return error_response unless signature
ServiceResponse.success(payload: { signature: signature, checksum: checksum })
end
private
attr_reader :file
def signature
return unless pdb_id
# Convert the GUID into an array of two-character hex strings
guid = pdb_id.first(SIGNATURE_LENGTH).unpack('H*').flat_map { |el| el.scan(TWO_CHARACTER_HEX_REGEX) }
# Reorder the GUID parts based on arbitrary lengths
guid = GUID_PARTS_LENGTHS.map { |length| guid.shift(length) }
# Concatenate the parts of the GUID back together
result = guid.first(3).map(&:reverse)
result << guid.last
result = result.join
result << GUID_AGE_PART
end
strong_memoize_attr :signature
# https://github.com/dotnet/corefx/blob/master/src/System.Reflection.Metadata/specs/PE-COFF.md#portable-pdb-checksum
def checksum
sha = OpenSSL::Digest.new('SHA256')
count = 0
chunk = (+'').force_encoding(Encoding::BINARY)
file.rewind
while file.read(SHA_CHUNK_SIZE, chunk)
count += 1
chunk[pdb_id] = TWENTY_ZEROED_BYTES if count == 1
sha.update(chunk)
end
sha.hexdigest
end
def pdb_id
# The ID is located in the first 256 bytes of the symbol `.pdb` file
chunk = file.read(GUID_CHUNK_SIZE)
return unless chunk
# Find the index of the first occurrence of 'Blob'
guid_index = chunk.index('Blob')
return unless guid_index
# Extract the binary GUID from the symbol content
chunk[(guid_index + GUID_START_INDEX)..(guid_index + GUID_END_INDEX)]
end
strong_memoize_attr :pdb_id
def error_response
ServiceResponse.error(message: 'Could not find the signature in the symbol file')
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Nuget::Symbols::ExtractSignatureAndChecksumService, feature_category: :package_registry do
let_it_be(:symbol_file_path) { expand_fixture_path('packages/nuget/symbol/package.pdb') }
let(:symbol_file) { File.new(symbol_file_path) }
let(:service) { described_class.new(symbol_file) }
after do
symbol_file.close
end
describe '#execute' do
subject { service.execute }
context 'with a valid symbol file' do
it 'returns the signature and checksum' do
payload = subject.payload
expect(payload[:signature]).to eq('b91a152048fc4b3883bf3cf73fbc03f1FFFFFFFF')
expect(payload[:checksum]).to eq('20151ab9fc48384b83bf3cf73fbc03f1d49166cc356139845f290d1d315256c0')
end
it 'reads the file in chunks' do
expect(symbol_file).to receive(:read).with(described_class::GUID_CHUNK_SIZE).and_call_original
expect(symbol_file).to receive(:read).with(described_class::SHA_CHUNK_SIZE, instance_of(String))
.at_least(:once).and_call_original
subject
end
end
context 'with an invalid symbol file' do
before do
allow(symbol_file).to receive(:read).and_return('invalid')
end
it 'returns an error' do
expect(subject).to be_error
expect(subject.message).to eq('Could not find the signature in the symbol file')
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Nuget
module Symbols
class CreateSymbolFilesService
ExtractionError = Class.new(StandardError)
SYMBOL_ENTRIES_LIMIT = 100
CONTENT_TYPE = 'application/octet-stream'
def initialize(package, package_zip_file)
@package = package
@symbol_entries = package_zip_file.glob('**/*.pdb')
end
def execute
return if symbol_entries.empty?
process_symbol_entries
rescue ExtractionError => e
Gitlab::ErrorTracking.track_exception(e, class: self.class.name, package_id: package.id)
end
private
attr_reader :package, :symbol_entries
def process_symbol_entries
Tempfile.create('nuget_extraction_symbol_file') do |tmp_file|
symbol_entries.each_with_index do |entry, index|
raise ExtractionError, 'too many symbol entries' if index >= SYMBOL_ENTRIES_LIMIT
entry.extract(tmp_file.path) { true }
File.open(tmp_file.path, 'rb') do |file|
create_symbol(entry.name, file)
end
end
end
rescue Zip::EntrySizeError => e
raise ExtractionError, "symbol file has the wrong entry size: #{e.message}"
rescue Zip::EntryNameError => e
raise ExtractionError, "symbol file has the wrong entry name: #{e.message}"
end
def create_symbol(path, file)
signature, checksum = extract_signature_and_checksum(file)
return if signature.blank? || checksum.blank?
::Packages::Nuget::Symbol.create!(
package: package,
file: { tempfile: file, filename: path.downcase, content_type: CONTENT_TYPE },
file_path: path,
signature: signature,
size: file.size,
file_sha256: checksum
)
rescue StandardError => e
Gitlab::ErrorTracking.track_exception(e, class: self.class.name, package_id: package.id)
end
def extract_signature_and_checksum(file)
::Packages::Nuget::Symbols::ExtractSignatureAndChecksumService
.new(file)
.execute
.payload
.values_at(:signature, :checksum)
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Nuget::Symbols::CreateSymbolFilesService, feature_category: :package_registry do
let_it_be(:package) { create(:nuget_package) }
let_it_be(:package_file) do
create(:package_file, :snupkg, package: package,
file_fixture: expand_fixture_path('packages/nuget/package_with_symbols.snupkg'))
end
let(:package_zip_file) { Zip::File.new(package_file.file) }
let(:service) { described_class.new(package, package_zip_file) }
describe '#execute' do
subject { service.execute }
shared_examples 'logging an error' do |error_class|
it 'logs the error' do
expect(Gitlab::ErrorTracking).to receive(:track_exception).with(
an_instance_of(error_class),
class: described_class.name,
package_id: package.id
)
subject
end
end
context 'when symbol files are found' do
it 'creates a symbol record and extracts the signature' do
expect_next_instance_of(Packages::Nuget::Symbols::ExtractSignatureAndChecksumService,
instance_of(File)) do |service|
expect(service).to receive(:execute).and_call_original
end
expect { subject }.to change { package.nuget_symbols.count }.by(1)
end
end
context 'when symbol files hit the limit' do
before do
stub_const("#{described_class}::SYMBOL_ENTRIES_LIMIT", 0)
end
it 'does not create a symbol record' do
expect { subject }.not_to change { package.nuget_symbols.count }
end
it_behaves_like 'logging an error', described_class::ExtractionError
end
context 'without a signature' do
before do
allow_next_instance_of(Packages::Nuget::Symbols::ExtractSignatureAndChecksumService) do |instance|
allow(instance).to receive(:execute).and_return(ServiceResponse.success(payload: { signature: nil }))
end
end
it 'does not call create! on the symbol record' do
expect(::Packages::Nuget::Symbol).not_to receive(:create!)
subject
end
end
context 'without a checksum' do
before do
allow_next_instance_of(Packages::Nuget::Symbols::ExtractSignatureAndChecksumService) do |instance|
allow(instance).to receive(:execute).and_return(ServiceResponse.success(payload: { checksum: nil }))
end
end
it 'does not call create! on the symbol record' do
expect(::Packages::Nuget::Symbol).not_to receive(:create!)
subject
end
end
context 'with existing duplicate symbol records' do
let_it_be(:symbol) { create(:nuget_symbol, package: package) }
before do
allow_next_instance_of(Packages::Nuget::Symbols::ExtractSignatureAndChecksumService) do |instance|
allow(instance).to receive(:execute).and_return(
ServiceResponse.success(payload: { signature: symbol.signature, checksum: symbol.file_sha256 })
)
end
end
it 'does not create a symbol record' do
expect { subject }.not_to change { package.nuget_symbols.count }
end
it_behaves_like 'logging an error', ActiveRecord::RecordInvalid
end
context 'when a symbol file has the wrong entry size' do
before do
allow_next_instance_of(Zip::Entry) do |instance|
allow(instance).to receive(:extract).and_raise(Zip::EntrySizeError)
end
end
it_behaves_like 'logging an error', described_class::ExtractionError
end
context 'when a symbol file has the wrong entry name' do
before do
allow_next_instance_of(Zip::Entry) do |instance|
allow(instance).to receive(:extract).and_raise(Zip::EntryNameError)
end
end
it_behaves_like 'logging an error', described_class::ExtractionError
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Conan
class SinglePackageSearchService # rubocop:disable Search/NamespacedClass
include Gitlab::Utils::StrongMemoize
def initialize(query, current_user)
@name, @version, @username, _ = query.split(%r{[@/]})
@current_user = current_user
end
def execute
ServiceResponse.success(payload: { results: search_results })
end
private
attr_reader :name, :version, :username, :current_user
def search_results
return [] unless can_access_project_package?
[package&.conan_recipe].compact
end
def package
project
.packages
.with_name(name)
.with_version(version)
.order_created
.last
end
def project
Project.find_by_full_path(full_path)
end
strong_memoize_attr :project
def full_path
::Packages::Conan::Metadatum.full_path_from(package_username: username)
end
def can_access_project_package?
Ability.allowed?(current_user, :read_package, project.try(:packages_policy_subject))
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Conan::SinglePackageSearchService, feature_category: :package_registry do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project, :public) }
let!(:conan_package) { create(:conan_package, project: project) }
let!(:conan_package2) { create(:conan_package, project: project) }
describe '#execute' do
context 'with a valid query and user with permissions' do
before do
allow_next_instance_of(described_class) do |service|
allow(service).to receive(:can_access_project_package?).and_return(true)
end
end
it 'returns the correct package' do
[conan_package, conan_package2].each do |package|
result = described_class.new(package.conan_recipe, user).execute
expect(result.status).to eq :success
expect(result[:results]).to match_array([package.conan_recipe])
end
end
end
context 'with a user without permissions' do
before do
allow_next_instance_of(described_class) do |service|
allow(service).to receive(:can_access_project_package?).and_return(false)
end
end
it 'returns an empty array' do
result = described_class.new(conan_package.conan_recipe, user).execute
expect(result.status).to eq :success
expect(result[:results]).to match_array([])
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Conan
class CreatePackageFileService
attr_reader :package, :file, :params
def initialize(package, file, params)
@package = package
@file = file
@params = params
end
def execute
package_file = package.package_files.build(
file: file,
size: params['file.size'],
file_name: params[:file_name],
file_sha1: params['file.sha1'],
file_md5: params['file.md5'],
conan_file_metadatum_attributes: {
recipe_revision: params[:recipe_revision],
package_revision: params[:package_revision],
conan_package_reference: params[:conan_package_reference],
conan_file_type: params[:conan_file_type]
}
)
if params[:build].present?
package_file.package_file_build_infos << package_file.package_file_build_infos.build(pipeline: params[:build].pipeline)
end
package_file.save!
package_file
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Conan::CreatePackageFileService, feature_category: :package_registry do
include WorkhorseHelpers
let_it_be(:package) { create(:conan_package) }
let_it_be(:user) { create(:user) }
describe '#execute' do
let(:file_name) { 'foo.tgz' }
subject { described_class.new(package, file, params).execute }
shared_examples 'a valid package_file' do
let(:params) do
{
file_name: file_name,
'file.md5': '12345',
'file.sha1': '54321',
'file.size': '128',
'file.type': 'txt',
recipe_revision: '0',
package_revision: '0',
conan_package_reference: '123456789',
conan_file_type: :package_file
}.with_indifferent_access
end
it 'creates a new package file' do
package_file = subject
expect(package_file).to be_valid
expect(package_file.file_name).to eq(file_name)
expect(package_file.file_md5).to eq('12345')
expect(package_file.size).to eq(128)
expect(package_file.conan_file_metadatum).to be_valid
expect(package_file.conan_file_metadatum.recipe_revision).to eq('0')
expect(package_file.conan_file_metadatum.package_revision).to eq('0')
expect(package_file.conan_file_metadatum.conan_package_reference).to eq('123456789')
expect(package_file.conan_file_metadatum.conan_file_type).to eq('package_file')
expect(package_file.file.read).to eq('content')
end
it_behaves_like 'assigns build to package file'
end
shared_examples 'a valid recipe_file' do
let(:params) do
{
file_name: file_name,
'file.md5': '12345',
'file.sha1': '54321',
'file.size': '128',
'file.type': 'txt',
recipe_revision: '0',
conan_file_type: :recipe_file
}.with_indifferent_access
end
it 'creates a new recipe file' do
package_file = subject
expect(package_file).to be_valid
expect(package_file.file_name).to eq(file_name)
expect(package_file.file_md5).to eq('12345')
expect(package_file.size).to eq(128)
expect(package_file.conan_file_metadatum).to be_valid
expect(package_file.conan_file_metadatum.recipe_revision).to eq('0')
expect(package_file.conan_file_metadatum.package_revision).to be_nil
expect(package_file.conan_file_metadatum.conan_package_reference).to be_nil
expect(package_file.conan_file_metadatum.conan_file_type).to eq('recipe_file')
expect(package_file.file.read).to eq('content')
end
it_behaves_like 'assigns build to package file'
end
context 'with temp file' do
let!(:file) do
upload_path = ::Packages::PackageFileUploader.workhorse_local_upload_path
file_path = upload_path + '/' + file_name
FileUtils.mkdir_p(upload_path)
File.write(file_path, 'content')
UploadedFile.new(file_path, filename: File.basename(file_path))
end
before do
allow_any_instance_of(Packages::PackageFileUploader).to receive(:size).and_return(128)
end
it_behaves_like 'a valid package_file'
it_behaves_like 'a valid recipe_file'
end
context 'with remote file' do
let!(:fog_connection) do
stub_package_file_object_storage(direct_upload: true)
end
before do
allow_any_instance_of(Packages::PackageFileUploader).to receive(:size).and_return(128)
end
let(:tmp_object) do
fog_connection.directories.new(key: 'packages').files.create( # rubocop:disable Rails/SaveBang
key: "tmp/uploads/#{file_name}",
body: 'content'
)
end
let(:file) { fog_to_uploaded_file(tmp_object) }
it_behaves_like 'a valid package_file'
it_behaves_like 'a valid recipe_file'
end
context 'file is missing' do
let(:file) { nil }
let(:params) do
{
file_name: file_name,
recipe_revision: '0',
conan_file_type: :recipe_file
}
end
it 'raises an error' do
expect { subject }.to raise_error(ActiveRecord::RecordInvalid)
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Conan
class SearchService < BaseService
include ActiveRecord::Sanitization::ClassMethods
WILDCARD = '*'
RECIPE_SEPARATOR = '@'
def execute
ServiceResponse.success(payload: { results: search_results })
end
private
def search_results
return [] if wildcard_query?
return search_for_single_package(sanitized_query) if params[:query].include?(RECIPE_SEPARATOR)
search_packages
end
def wildcard_query?
params[:query] == WILDCARD
end
def sanitized_query
@sanitized_query ||= sanitize_sql_like(params[:query].delete(WILDCARD))
end
def search_for_single_package(query)
::Packages::Conan::SinglePackageSearchService
.new(query, current_user)
.execute[:results]
end
def search_packages
::Packages::Conan::PackageFinder
.new(current_user, { query: build_query }, project: project)
.execute
.map(&:conan_recipe)
end
def build_query
return "#{sanitized_query}%" if params[:query].end_with?(WILDCARD)
sanitized_query
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Conan::SearchService, feature_category: :package_registry do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project, :public) }
let!(:conan_package) { create(:conan_package, project: project) }
let!(:conan_package2) { create(:conan_package, project: project) }
subject { described_class.new(project, user, query: query) }
before do
project.add_developer(user)
end
describe '#execute' do
context 'with wildcard' do
let(:partial_name) { conan_package.name.first[0, 3] }
let(:query) { "#{partial_name}*" }
it 'makes a wildcard query' do
result = subject.execute
expect(result.status).to eq :success
expect(result.payload).to eq(results: [conan_package2.conan_recipe, conan_package.conan_recipe])
end
end
context 'with only wildcard' do
let(:query) { '*' }
it 'returns empty' do
result = subject.execute
expect(result.status).to eq :success
expect(result.payload).to eq(results: [])
end
end
context 'with no wildcard' do
let(:query) { conan_package.name }
it 'makes a search using the beginning of the recipe' do
result = subject.execute
expect(result.status).to eq :success
expect(result.payload).to eq(results: [conan_package.conan_recipe])
end
end
context 'with full recipe match' do
let(:query) { conan_package.conan_recipe }
it 'makes an exact search' do
result = subject.execute
expect(result.status).to eq :success
expect(result.payload).to eq(results: [conan_package.conan_recipe])
end
end
context 'with malicious query' do
let(:query) { 'DROP TABLE foo;' }
it 'returns empty' do
result = subject.execute
expect(result.status).to eq :success
expect(result.payload).to eq(results: [])
end
end
context 'for project' do
let_it_be(:project2) { create(:project, :public) }
let(:query) { conan_package.name }
let!(:conan_package3) { create(:conan_package, name: conan_package.name, project: project2) }
context 'when passing a project' do
it 'returns only packages of the given project' do
result = subject.execute
expect(result.status).to eq :success
expect(result[:results]).to match_array([conan_package.conan_recipe])
end
end
context 'when passing a project with nil' do
it 'returns all packages' do
result = described_class.new(nil, user, query: query).execute
expect(result.status).to eq :success
expect(result[:results]).to eq([conan_package3.conan_recipe, conan_package.conan_recipe])
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Conan
class CreatePackageService < ::Packages::CreatePackageService
def execute
create_package!(:conan,
name: params[:package_name],
version: params[:package_version],
conan_metadatum_attributes: {
package_username: params[:package_username],
package_channel: params[:package_channel]
}
)
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Conan::CreatePackageService, feature_category: :package_registry do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
subject(:service) { described_class.new(project, user, params) }
describe '#execute' do
subject(:package) { service.execute }
context 'valid params' do
let(:params) do
{
package_name: 'my-pkg',
package_version: '1.0.0',
package_username: ::Packages::Conan::Metadatum.package_username_from(full_path: project.full_path),
package_channel: 'stable'
}
end
it 'creates a new package' do
expect(package).to be_valid
expect(package.name).to eq(params[:package_name])
expect(package.version).to eq(params[:package_version])
expect(package.package_type).to eq('conan')
expect(package.conan_metadatum.package_username).to eq(params[:package_username])
expect(package.conan_metadatum.package_channel).to eq(params[:package_channel])
end
it_behaves_like 'assigns the package creator'
it_behaves_like 'assigns build to package'
it_behaves_like 'assigns status to package'
end
context 'invalid params' do
let(:params) do
{
package_name: 'my-pkg',
package_version: '1.0.0',
package_username: 'foo/bar',
package_channel: 'stable'
}
end
it 'fails' do
expect { package }.to raise_exception(ActiveRecord::RecordInvalid)
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module TerraformModule
class CreatePackageService < ::Packages::CreatePackageService
include Gitlab::Utils::StrongMemoize
def execute
return error('Version is empty.', 400) if params[:module_version].blank?
return error('Access Denied', 403) if current_package_exists_elsewhere?
return error('Package version already exists.', 403) if current_package_version_exists?
return error('File is too large.', 400) if file_size_exceeded?
ApplicationRecord.transaction { create_terraform_module_package! }
end
private
def create_terraform_module_package!
package = create_package!(:terraform_module, name: name, version: params[:module_version])
::Packages::CreatePackageFileService.new(package, file_params).execute
package
end
def current_package_exists_elsewhere?
::Packages::Package
.for_projects(project.root_namespace.all_projects.id_not_in(project.id))
.with_package_type(:terraform_module)
.with_name(name)
.not_pending_destruction
.exists?
end
def current_package_version_exists?
project.packages
.with_package_type(:terraform_module)
.with_name(name)
.with_version(params[:module_version])
.not_pending_destruction
.exists?
end
def name
"#{params[:module_name]}/#{params[:module_system]}"
end
strong_memoize_attr :name
def file_name
"#{params[:module_name]}-#{params[:module_system]}-#{params[:module_version]}.tgz"
end
strong_memoize_attr :file_name
def file_params
{
file: params[:file],
size: params[:file].size,
file_sha256: params[:file].sha256,
file_name: file_name,
build: params[:build]
}
end
def file_size_exceeded?
project.actual_limits.exceeded?(:generic_packages_max_file_size, params[:file].size)
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::TerraformModule::CreatePackageService, feature_category: :package_registry do
let_it_be(:namespace) { create(:namespace) }
let_it_be(:project) { create(:project, namespace: namespace) }
let_it_be(:user) { create(:user) }
let_it_be(:sha256) { '440e5e148a25331bbd7991575f7d54933c0ebf6cc735a18ee5066ac1381bb590' }
let(:overrides) { {} }
let(:params) do
{
module_name: 'foo',
module_system: 'bar',
module_version: '1.0.1',
file: UploadedFile.new(Tempfile.new('test').path, sha256: sha256),
file_name: 'foo-bar-1.0.1.tgz'
}.merge(overrides)
end
subject { described_class.new(project, user, params).execute }
describe '#execute' do
shared_examples 'creating a package' do
it 'creates a package' do
expect { subject }
.to change { ::Packages::Package.count }.by(1)
.and change { ::Packages::Package.terraform_module.count }.by(1)
end
end
context 'valid package' do
it_behaves_like 'creating a package'
end
context 'package already exists elsewhere' do
let(:project2) { create(:project, namespace: namespace) }
let!(:existing_package) { create(:terraform_module_package, project: project2, name: 'foo/bar', version: '1.0.0') }
it { expect(subject[:http_status]).to eq 403 }
it { expect(subject[:message]).to be 'Access Denied' }
context 'marked as pending_destruction' do
before do
existing_package.pending_destruction!
end
it_behaves_like 'creating a package'
end
end
context 'version already exists' do
let!(:existing_version) { create(:terraform_module_package, project: project, name: 'foo/bar', version: '1.0.1') }
it { expect(subject[:http_status]).to eq 403 }
it { expect(subject[:message]).to be 'Package version already exists.' }
context 'marked as pending_destruction' do
before do
existing_version.pending_destruction!
end
it_behaves_like 'creating a package'
end
end
context 'with empty version' do
let(:overrides) { { module_version: '' } }
it { expect(subject[:http_status]).to eq 400 }
it { expect(subject[:message]).to eq 'Version is empty.' }
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Generic
class CreatePackageFileService < BaseService
def execute
::Packages::Package.transaction do
create_package_file(find_or_create_package)
end
end
private
def find_or_create_package
package_params = {
name: params[:package_name],
version: params[:package_version],
build: params[:build],
status: params[:status]
}
package = ::Packages::Generic::FindOrCreatePackageService
.new(project, current_user, package_params)
.execute
unless Namespace::PackageSetting.duplicates_allowed?(package)
raise ::Packages::DuplicatePackageError if target_file_is_duplicate?(package)
end
package.update_column(:status, params[:status]) if params[:status] && params[:status] != package.status
package.create_build_infos!(params[:build])
package
end
def create_package_file(package)
file_params = {
file: params[:file],
size: params[:file].size,
file_sha256: params[:file].sha256,
file_name: params[:file_name],
build: params[:build]
}
::Packages::CreatePackageFileService.new(package, file_params).execute
end
def target_file_is_duplicate?(package)
package
.package_files
.with_file_name(params[:file_name])
.not_pending_destruction
.exists?
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Generic::CreatePackageFileService, feature_category: :package_registry do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
let_it_be(:pipeline) { create(:ci_pipeline, user: user) }
let_it_be(:file_name) { 'myfile.tar.gz.1' }
let(:build) { double('build', pipeline: pipeline) }
describe '#execute' do
let_it_be(:package) { create(:generic_package, project: project) }
let(:sha256) { '440e5e148a25331bbd7991575f7d54933c0ebf6cc735a18ee5066ac1381bb590' }
let(:temp_file) { Tempfile.new("test") }
let(:file) { UploadedFile.new(temp_file.path, sha256: sha256) }
let(:package_service) { double }
let(:params) do
{
package_name: 'mypackage',
package_version: '0.0.1',
file: file,
file_name: file_name,
build: build
}
end
let(:package_params) do
{
name: params[:package_name],
version: params[:package_version],
build: params[:build],
status: nil
}
end
subject(:execute_service) { described_class.new(project, user, params).execute }
before do
FileUtils.touch(temp_file)
expect(::Packages::Generic::FindOrCreatePackageService).to receive(:new).with(project, user, package_params).and_return(package_service)
expect(package_service).to receive(:execute).and_return(package)
end
after do
FileUtils.rm_f(temp_file)
end
it 'creates package file', :aggregate_failures do
expect { execute_service }.to change { package.package_files.count }.by(1)
.and change { Packages::PackageFileBuildInfo.count }.by(1)
package_file = package.package_files.last
aggregate_failures do
expect(package_file.package.status).to eq('default')
expect(package_file.package).to eq(package)
expect(package_file.file_name).to eq(file_name)
expect(package_file.size).to eq(file.size)
expect(package_file.file_sha256).to eq(sha256)
end
end
context 'with a status' do
let(:params) { super().merge(status: 'hidden') }
let(:package_params) { super().merge(status: 'hidden') }
it 'updates an existing packages status' do
expect { execute_service }.to change { package.package_files.count }.by(1)
.and change { Packages::PackageFileBuildInfo.count }.by(1)
package_file = package.package_files.last
aggregate_failures do
expect(package_file.package.status).to eq('hidden')
end
end
end
it_behaves_like 'assigns build to package file'
context 'with existing package' do
let_it_be(:duplicate_file) { create(:package_file, package: package, file_name: file_name) }
it { expect { execute_service }.to change { project.package_files.count }.by(1) }
context 'when duplicates are not allowed' do
before do
package.project.namespace.package_settings.update!(generic_duplicates_allowed: false)
end
it 'does not allow duplicates' do
expect { execute_service }.to raise_error(::Packages::DuplicatePackageError)
.and change { project.package_files.count }.by(0)
end
context 'when the file is pending destruction' do
before do
duplicate_file.update_column(:status, :pending_destruction)
end
it 'allows creating the file' do
expect { execute_service }.to change { project.package_files.count }.by(1)
end
end
context 'when the package name matches the exception regex' do
before do
package.project.namespace.package_settings.update!(generic_duplicate_exception_regex: '.*')
end
it { expect { execute_service }.to change { project.package_files.count }.by(1) }
end
end
context 'with multiple files for the same package and the same pipeline' do
let(:file_2_params) { params.merge(file_name: 'myfile.tar.gz.2', file: file2) }
let(:file_3_params) { params.merge(file_name: 'myfile.tar.gz.3', file: file3) }
let(:temp_file2) { Tempfile.new("test2") }
let(:temp_file3) { Tempfile.new("test3") }
let(:file2) { UploadedFile.new(temp_file2.path, sha256: sha256) }
let(:file3) { UploadedFile.new(temp_file3.path, sha256: sha256) }
before do
FileUtils.touch(temp_file2)
FileUtils.touch(temp_file3)
expect(::Packages::Generic::FindOrCreatePackageService).to receive(:new).with(project, user, package_params).and_return(package_service).twice
expect(package_service).to receive(:execute).and_return(package).twice
end
after do
FileUtils.rm_f(temp_file2)
FileUtils.rm_f(temp_file3)
end
it 'creates the build info only once' do
expect do
described_class.new(project, user, params).execute
described_class.new(project, user, file_2_params).execute
described_class.new(project, user, file_3_params).execute
end.to change { package.build_infos.count }.by(1)
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Generic
class FindOrCreatePackageService < ::Packages::CreatePackageService
def execute
find_or_create_package!(::Packages::Package.package_types['generic'])
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Generic::FindOrCreatePackageService, feature_category: :package_registry do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
let_it_be(:ci_build) { create(:ci_build, :running, user: user) }
let(:params) do
{
name: 'mypackage',
version: '0.0.1'
}
end
describe '#execute' do
context 'when packages does not exist yet' do
it 'creates package' do
service = described_class.new(project, user, params)
expect { service.execute }.to change { project.packages.generic.count }.by(1)
package = project.packages.generic.last
aggregate_failures do
expect(package.creator).to eq(user)
expect(package.name).to eq('mypackage')
expect(package.version).to eq('0.0.1')
expect(package.last_build_info).to be_nil
end
end
it 'creates package and package build info when build is provided' do
service = described_class.new(project, user, params.merge(build: ci_build))
expect { service.execute }.to change { project.packages.generic.count }.by(1)
package = project.packages.generic.last
aggregate_failures do
expect(package.creator).to eq(user)
expect(package.name).to eq('mypackage')
expect(package.version).to eq('0.0.1')
expect(package.last_build_info.pipeline).to eq(ci_build.pipeline)
end
end
end
context 'when packages already exists' do
let!(:package) { project.packages.generic.create!(params) }
context 'when package was created manually' do
it 'finds the package and does not create package build info even if build is provided' do
service = described_class.new(project, user, params.merge(build: ci_build))
expect do
found_package = service.execute
expect(found_package).to eq(package)
end.not_to change { project.packages.generic.count }
expect(package.reload.last_build_info).to be_nil
end
end
context 'when package was created by pipeline' do
let(:pipeline) { create(:ci_pipeline, project: project) }
before do
package.build_infos.create!(pipeline: pipeline)
end
it 'finds the package and does not change package build info even if build is provided' do
service = described_class.new(project, user, params.merge(build: ci_build))
expect do
found_package = service.execute
expect(found_package).to eq(package)
end.not_to change { project.packages.generic.count }
expect(package.reload.last_build_info.pipeline).to eq(pipeline)
end
end
context 'when a pending_destruction package exists', :aggregate_failures do
let!(:package) { project.packages.generic.create!(params.merge(status: :pending_destruction)) }
it 'creates a new package' do
service = described_class.new(project, user, params)
expect { service.execute }.to change { project.packages.generic.count }.by(1)
package = project.packages.generic.last
expect(package.creator).to eq(user)
expect(package.name).to eq('mypackage')
expect(package.version).to eq('0.0.1')
expect(package.last_build_info).to be_nil
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Rpm
class ParsePackageService
include ::Gitlab::Utils::StrongMemoize
BUILD_ATTRIBUTES_METHOD_NAMES = %i[changelogs requirements provides].freeze
STATIC_ATTRIBUTES = %i[name version release summary description arch
license sourcerpm group buildhost packager vendor].freeze
CHANGELOGS_RPM_KEYS = %i[changelogtext changelogtime].freeze
REQUIREMENTS_RPM_KEYS = %i[requirename requireversion requireflags].freeze
PROVIDES_RPM_KEYS = %i[providename provideflags provideversion].freeze
def initialize(package_file)
@rpm = RPM::File.new(package_file)
end
def execute
raise ArgumentError, 'Unable to parse package' unless valid_package?
{
files: rpm.files || [],
epoch: package_tags[:epoch] || '0',
changelogs: build_changelogs,
requirements: build_requirements,
provides: build_provides,
directories: package_tags[:dirnames]
}.merge(extract_static_attributes)
end
private
attr_reader :rpm
def valid_package?
rpm.files && package_tags && true
rescue RuntimeError
# if arr-pm throws an error due to an incorrect file format,
# we just want this validation to fail rather than throw an exception
false
end
def package_tags
rpm.tags
end
strong_memoize_attr :package_tags
def extract_static_attributes
STATIC_ATTRIBUTES.index_with do |attribute|
package_tags[attribute]
end
end
# Define methods for building RPM attribute data from parsed package
# Transform
# changelogtime: [123, 234],
# changelogname: ["First", "Second"]
# changelogtext: ["Work1", "Work2"]
# Into
# changelog: [
# {changelogname: "First", changelogtext: "Work1", changelogtime: 123},
# {changelogname: "Second", changelogtext: "Work2", changelogtime: 234}
# ]
BUILD_ATTRIBUTES_METHOD_NAMES.each do |resource|
define_method("build_#{resource}") do
resource_keys = self.class.const_get("#{resource.upcase}_RPM_KEYS", false).dup
return [] if resource_keys.any? { package_tags[_1].blank? }
first_attributes = package_tags[resource_keys.first]
zipped_data = first_attributes.zip(*resource_keys[1..].map { package_tags[_1] })
build_hashes(resource_keys, zipped_data)
end
end
def build_hashes(resource_keys, zipped_data)
zipped_data.map do |data|
resource_keys.zip(data).to_h
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Rpm::ParsePackageService, feature_category: :package_registry do
let(:package_file) { File.open('spec/fixtures/packages/rpm/hello-0.0.1-1.fc29.x86_64.rpm') }
describe 'dynamic private methods' do
described_class::BUILD_ATTRIBUTES_METHOD_NAMES.each do |attribute|
it 'define dynamic build attribute method' do
expect(described_class).to be_private_method_defined("build_#{attribute}")
end
end
end
describe '#execute' do
subject { described_class.new(package_file).execute }
shared_examples 'valid package parsing' do
it 'return hash' do
expect(subject).to be_a(Hash)
end
it 'has all static attribute keys' do
expect(subject.keys).to include(*described_class::STATIC_ATTRIBUTES)
end
it 'includes epoch attribute' do
expect(subject[:epoch]).not_to be_blank
end
it 'has all built attributes with array values' do
result = subject
described_class::BUILD_ATTRIBUTES_METHOD_NAMES.each do |attribute|
expect(result).to have_key(attribute)
expect(result[attribute]).to be_a(Array)
end
end
end
context 'when wrong format file received' do
let(:package_file) { File.open('spec/fixtures/rails_sample.jpg') }
it 'raise error' do
expect { subject }.to raise_error(ArgumentError)
end
end
context 'when valid file uploaded' do
context 'when .rpm file uploaded' do
it_behaves_like 'valid package parsing'
end
context 'when .src.rpm file uploaded' do
let(:package_file) { File.open('spec/fixtures/packages/rpm/hello-0.0.1-1.fc29.src.rpm') }
it_behaves_like 'valid package parsing'
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Rpm
module RepositoryMetadata
class BuildRepomdXmlService
ROOT_ATTRIBUTES = {
xmlns: 'http://linux.duke.edu/metadata/repo',
'xmlns:rpm': 'http://linux.duke.edu/metadata/rpm'
}.freeze
ALLOWED_DATA_VALUE_KEYS = %i[checksum open-checksum location timestamp size open-size].freeze
# Expected `data` structure
#
# data = {
# filelists: {
# checksum: { type: "sha256", value: "123" },
# location: { href: "repodata/123-filelists.xml.gz" },
# ...
# },
# ...
# }
def initialize(data)
@data = data
end
def execute
Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
xml.repomd(ROOT_ATTRIBUTES) do
xml.revision Time.now.to_i
build_data_info(xml)
end
end.to_xml
end
private
attr_reader :data
def build_data_info(xml)
data.each do |filename, info|
xml.data(type: filename) do
build_file_info(info, xml)
end
end
end
def build_file_info(info, xml)
info.slice(*ALLOWED_DATA_VALUE_KEYS).each do |key, attributes|
value = attributes.delete(:value)
xml.method_missing(key, value, attributes)
end
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Rpm::RepositoryMetadata::BuildRepomdXmlService, feature_category: :package_registry do
describe '#execute' do
subject { described_class.new(data).execute }
let(:data) do
{
filelists: {
checksum: { type: "sha256", value: "123" },
'open-checksum': { type: "sha256", value: "123" },
location: { href: "repodata/123-filelists.xml.gz" },
timestamp: { value: 1644602784 },
size: { value: 11111 },
'open-size': { value: 11111 }
},
primary: {
checksum: { type: "sha256", value: "234" },
'open-checksum': { type: "sha256", value: "234" },
location: { href: "repodata/234-primary.xml.gz" },
timestamp: { value: 1644602784 },
size: { value: 22222 },
'open-size': { value: 22222 }
},
other: {
checksum: { type: "sha256", value: "345" },
'open-checksum': { type: "sha256", value: "345" },
location: { href: "repodata/345-other.xml.gz" },
timestamp: { value: 1644602784 },
size: { value: 33333 },
'open-size': { value: 33333 }
}
}
end
let(:creation_timestamp) { 111111 }
before do
allow(Time).to receive(:now).and_return(creation_timestamp)
end
it 'generate valid xml' do
# Have one root attribute
result = Nokogiri::XML::Document.parse(subject)
expect(result.children.count).to eq(1)
# Root attribute name is 'repomd'
root = result.children.first
expect(root.name).to eq('repomd')
# Have the same count of 'data' tags as count of keys in 'data'
expect(result.css('data').count).to eq(data.count)
end
it 'has all data info' do
result = Nokogiri::XML::Document.parse(subject).remove_namespaces!
data.each do |tag_name, tag_attributes|
tag_attributes.each_key do |key|
expect(result.at("//repomd/data[@type=\"#{tag_name}\"]/#{key}")).not_to be_nil
end
end
end
context 'when data values has unexpected keys' do
let(:data) do
{
filelists: described_class::ALLOWED_DATA_VALUE_KEYS.each_with_object({}) do |key, result|
result[:"#{key}-wrong"] = { value: 'value' }
end
}
end
it 'ignores wrong keys' do
result = Nokogiri::XML::Document.parse(subject).remove_namespaces!
data.each do |tag_name, tag_attributes|
tag_attributes.each_key do |key|
expect(result.at("//repomd/data[@type=\"#{tag_name}\"]/#{key}")).to be_nil
end
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Rpm
module RepositoryMetadata
class BuildOtherXmlService < BuildXmlBaseService
ROOT_TAG = 'otherdata'
ROOT_ATTRIBUTES = {
xmlns: 'http://linux.duke.edu/metadata/other',
packages: '0'
}.freeze
def execute
super do |xml|
xml.package(pkgid: data[:pkgid], name: data[:name], arch: data[:arch]) do
xml.version epoch: data[:epoch], ver: data[:version], rel: data[:release]
build_changelog_nodes(xml)
end
end
end
private
def build_changelog_nodes(xml)
data[:changelogs].each do |changelog|
xml.changelog changelog[:changelogtext], date: changelog[:changelogtime]
end
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Rpm::RepositoryMetadata::BuildOtherXmlService, feature_category: :package_registry do
describe '#execute' do
subject { described_class.new(data).execute }
include_context 'with rpm package data'
let(:data) { xml_update_params }
let(:changelog_xpath) { "//package/changelog" }
it 'adds all changelog nodes' do
result = subject
expect(result.xpath(changelog_xpath).count).to eq(data[:changelogs].count)
end
it 'set required date attribute' do
result = subject
data[:changelogs].each do |changelog|
expect(result.at("#{changelog_xpath}[@date=\"#{changelog[:changelogtime]}\"]")).not_to be_nil
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Rpm
module RepositoryMetadata
class BuildPrimaryXmlService < BuildXmlBaseService
ROOT_TAG = 'metadata'
ROOT_ATTRIBUTES = {
xmlns: 'http://linux.duke.edu/metadata/common',
'xmlns:rpm': 'http://linux.duke.edu/metadata/rpm',
packages: '0'
}.freeze
# Nodes that have only text without attributes
BASE_ATTRIBUTES = %i[name arch summary description url packager].freeze
FORMAT_NODE_BASE_ATTRIBUTES = %i[license vendor group buildhost sourcerpm].freeze
def execute
super do |xml|
xml.package(type: :rpm, 'xmlns:rpm': 'http://linux.duke.edu/metadata/rpm') do
build_base_attributes(xml)
xml.version epoch: data[:epoch], ver: data[:version], rel: data[:release]
xml.checksum data[:pkgid], type: 'sha256', pkgid: 'YES'
xml.size package: data[:packagesize], installed: data[:installedsize], archive: data[:archivesize]
xml.time file: data[:filetime], build: data[:buildtime]
xml.location href: data[:location] if data[:location].present?
build_format_node(xml)
end
end
end
private
def build_base_attributes(xml)
BASE_ATTRIBUTES.each do |attribute|
xml.method_missing(attribute, data[attribute]) if data[attribute].present?
end
end
def build_format_node(xml)
xml.format do
build_base_format_attributes(xml)
build_provides_node(xml)
build_requires_node(xml)
end
end
def build_base_format_attributes(xml)
FORMAT_NODE_BASE_ATTRIBUTES.each do |attribute|
xml[:rpm].method_missing(attribute, data[attribute]) if data[attribute].present?
end
end
def build_requires_node(xml)
xml[:rpm].requires do
data[:requirements].each do |requires|
xml[:rpm].entry(
name: requires[:requirename],
flags: requires[:requireflags],
ver: requires[:requireversion]
)
end
end
end
def build_provides_node(xml)
xml[:rpm].provides do
data[:provides].each do |provides|
xml[:rpm].entry(
name: provides[:providename],
flags: provides[:provideflags],
ver: provides[:provideversion])
end
end
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Rpm::RepositoryMetadata::BuildPrimaryXmlService, feature_category: :package_registry do
describe '#execute' do
subject { described_class.new(data).execute }
include_context 'with rpm package data'
let(:data) { xml_update_params }
let(:required_text_only_attributes) { %i[description summary arch name] }
it 'adds node with required_text_only_attributes' do
result = subject
required_text_only_attributes.each do |attribute|
expect(
result.at("//package/#{attribute}").text
).to eq(data[attribute])
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Rpm
module RepositoryMetadata
class BuildFilelistXmlService < BuildXmlBaseService
ROOT_TAG = 'filelists'
ROOT_ATTRIBUTES = {
xmlns: 'http://linux.duke.edu/metadata/filelists',
packages: '0'
}.freeze
def execute
super do |xml|
xml.package(pkgid: data[:pkgid], name: data[:name], arch: data[:arch]) do
xml.version epoch: data[:epoch], ver: data[:version], rel: data[:release]
build_file_nodes(xml)
end
end
end
private
def build_file_nodes(xml)
data[:files].each do |path|
attributes = dir?(path) ? { type: 'dir' } : {}
xml.file path, **attributes
end
end
def dir?(path)
# Add trailing slash to path to check
# if it exists in directories list
data[:directories].include? File.join(path, '')
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Rpm::RepositoryMetadata::BuildFilelistXmlService, feature_category: :package_registry do
describe '#execute' do
subject { described_class.new(data).execute }
include_context 'with rpm package data'
let(:data) { xml_update_params }
let(:file_xpath) { "//package/file" }
it 'adds all file nodes' do
result = subject
expect(result.xpath(file_xpath).count).to eq(data[:files].count)
end
describe 'setting type attribute' do
context 'when all files are directories' do
let(:dirs) do
3.times.map { generate_directory } # rubocop:disable Performance/TimesMap
end
let(:files) do
5.times.map { FFaker::Filesystem.file_name(dirs.sample) } # rubocop:disable Performance/TimesMap
end
let(:data) do
{
directories: dirs.map { "#{_1}/" }, # Add trailing slash as in original package
files: dirs + files
}
end
it 'set dir type attribute for directories only' do
result = subject
result.xpath(file_xpath).each do |tag|
if dirs.include?(tag.content)
expect(tag.attributes['type']&.value).to eq('dir')
else
expect(tag.attributes['type']).to be_nil
end
end
end
end
def generate_directory
FFaker::Lorem.words(3).join('/')
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Rpm
module RepositoryMetadata
class UpdateXmlService
BUILDERS = {
other: ::Packages::Rpm::RepositoryMetadata::BuildOtherXmlService,
primary: ::Packages::Rpm::RepositoryMetadata::BuildPrimaryXmlService,
filelist: ::Packages::Rpm::RepositoryMetadata::BuildFilelistXmlService
}.freeze
def initialize(filename:, xml: nil, data: {})
@builder_class = BUILDERS[filename]
raise ArgumentError, "Filename must be one of: #{BUILDERS.keys.join(', ')}" if @builder_class.nil?
@xml = Nokogiri::XML(xml) if xml.present?
@data = data
@filename = filename
end
def execute
return build_empty_structure if xml.blank?
remove_existing_packages
update_xml_document
update_package_count
xml.to_xml
end
private
attr_reader :xml, :data, :builder_class, :filename
def build_empty_structure
Nokogiri::XML::Builder.new(encoding: 'UTF-8') do |xml|
xml.method_missing(builder_class::ROOT_TAG, builder_class::ROOT_ATTRIBUTES)
end.to_xml
end
def update_xml_document
# Add to the root xml element a new package metadata node
xml.at(builder_class::ROOT_TAG).add_child(builder_class.new(data).execute)
end
def update_package_count
packages_count = xml.css("//#{builder_class::ROOT_TAG}/package").count
xml.at(builder_class::ROOT_TAG).attributes["packages"].value = packages_count.to_s
end
def remove_existing_packages
case filename
when :primary
xml.search("checksum:contains('#{data[:pkgid]}')").each { _1.parent&.remove }
else
xml.search("[pkgid='#{data[:pkgid]}']").each(&:remove)
end
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Rpm::RepositoryMetadata::UpdateXmlService, feature_category: :package_registry do
describe '#execute' do
subject { described_class.new(filename: filename, xml: xml, data: data).execute }
let(:xml) { nil }
let(:data) { nil }
shared_examples 'handling not implemented xml filename' do
let(:filename) { :not_implemented_yet }
let(:empty_xml) { '' }
it 'raise error' do
expect { subject }.to raise_error(ArgumentError)
end
end
shared_context 'with primary xml file data' do
let(:filename) { :primary }
let(:empty_xml) do
<<~XML
<?xml version="1.0" encoding="UTF-8"?>
<metadata xmlns="http://linux.duke.edu/metadata/common" xmlns:rpm="http://linux.duke.edu/metadata/rpm" packages="0"/>
XML
end
end
shared_context 'with other xml file data' do
let(:filename) { :other }
let(:empty_xml) do
<<~XML
<?xml version="1.0" encoding="UTF-8"?>
<otherdata xmlns="http://linux.duke.edu/metadata/other" packages="0"/>
XML
end
end
shared_context 'with filelist xml file data' do
let(:filename) { :filelist }
let(:empty_xml) do
<<~XML
<?xml version="1.0" encoding="UTF-8"?>
<filelists xmlns="http://linux.duke.edu/metadata/filelists" packages="0"/>
XML
end
end
context 'when building empty xml' do
shared_examples 'generating empty xml' do
it 'generate expected xml' do
expect(subject).to eq(empty_xml)
end
end
it_behaves_like 'handling not implemented xml filename'
context "for 'primary' xml file" do
include_context 'with primary xml file data'
it_behaves_like 'generating empty xml'
end
context "for 'other' xml file" do
include_context 'with other xml file data'
it_behaves_like 'generating empty xml'
end
context "for 'filelist' xml file" do
include_context 'with filelist xml file data'
it_behaves_like 'generating empty xml'
end
end
context 'when updating xml file' do
include_context 'with rpm package data'
let(:xml) { empty_xml }
let(:data) { xml_update_params }
let(:builder_class) { described_class::BUILDERS[filename] }
shared_examples 'updating rpm xml file' do
context 'when updating existing xml' do
shared_examples 'changing root tag attribute' do
it "increment previous 'packages' value by 1" do
previous_value = Nokogiri::XML(xml).at(builder_class::ROOT_TAG).attributes["packages"].value.to_i
new_value = Nokogiri::XML(subject).at(builder_class::ROOT_TAG).attributes["packages"].value.to_i
expect(previous_value + 1).to eq(new_value)
end
end
it 'generate valid xml add expected xml node to existing xml' do
# Have one root attribute
result = Nokogiri::XML::Document.parse(subject).remove_namespaces!
expect(result.children.count).to eq(1)
# Root node has 1 child with generated node
expect(result.xpath("//#{builder_class::ROOT_TAG}/package").count).to eq(1)
end
context 'when empty xml' do
it_behaves_like 'changing root tag attribute'
end
context 'when xml has children' do
context "when node with given 'pkgid' does not exist yet" do
let(:uniq_node_data) do
xml_update_params.tap do |data|
data[:pkgid] = SecureRandom.uuid
end
end
let(:xml) { build_xml_from(uniq_node_data) }
it 'has children nodes' do
existing_xml = Nokogiri::XML::Document.parse(xml).remove_namespaces!
expect(existing_xml.xpath('//package').count).to eq(1)
end
it_behaves_like 'changing root tag attribute'
end
context "when node with given 'pkgid' already exist" do
let(:existing_node_data) do
existing_data = data.dup
existing_data[:name] = FFaker::Lorem.word
existing_data
end
let(:xml) { build_xml_from(existing_node_data) }
it 'has children nodes' do
existing_xml = Nokogiri::XML::Document.parse(xml).remove_namespaces!
expect(existing_xml.xpath('//package').count).to eq(1)
end
it 'replace existing node with new data' do
existing_xml = Nokogiri::XML::Document.parse(xml).remove_namespaces!
result = Nokogiri::XML::Document.parse(subject).remove_namespaces!
expect(result.xpath('//package').count).to eq(1)
expect(result.xpath('//package').first.to_xml).not_to eq(existing_xml.xpath('//package').first.to_xml)
end
end
def build_xml_from(data)
described_class.new(filename: filename, xml: empty_xml, data: data).execute
end
end
end
end
it_behaves_like 'handling not implemented xml filename'
context "for 'primary' xml file" do
include_context 'with primary xml file data'
it_behaves_like 'updating rpm xml file'
end
context "for 'other' xml file" do
include_context 'with other xml file data'
it_behaves_like 'updating rpm xml file'
end
context "for 'filelist' xml file" do
include_context 'with filelist xml file data'
it_behaves_like 'updating rpm xml file'
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
require 'rubygems/package'
module Packages
module Helm
class ExtractFileMetadataService
ExtractionError = Class.new(StandardError)
# Charts must be smaller than 1M because of the storage limitations of Kubernetes objects.
# based on https://helm.sh/docs/chart_template_guide/accessing_files/
MAX_FILE_SIZE = 1.megabytes.freeze
def initialize(package_file)
@package_file = package_file
end
def execute
raise ExtractionError, 'invalid package file' unless valid_package_file?
metadata
end
private
def valid_package_file?
@package_file && @package_file.package&.helm? && !@package_file.file.empty_size?
end
def metadata
YAML.safe_load(chart_yaml_content)
rescue Psych::Exception => e
raise ExtractionError, "Error while parsing Chart.yaml: #{e.message}"
end
def chart_yaml_content
@package_file.file.use_open_file do |file|
tar_reader = Gem::Package::TarReader.new(Zlib::GzipReader.new(file))
chart_yaml = tar_reader.find do |entry|
next unless entry.file?
entry.full_name.end_with?('/Chart.yaml')
end
raise ExtractionError, 'Chart.yaml not found within a directory' unless chart_yaml
raise ExtractionError, 'Chart.yaml too big' if chart_yaml.size > MAX_FILE_SIZE
chart_yaml.read
ensure
tar_reader.close
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Helm::ExtractFileMetadataService, feature_category: :package_registry do
let_it_be(:package_file) { create(:helm_package_file) }
let(:service) { described_class.new(package_file) }
let(:expected) do
{
'apiVersion' => 'v2',
'description' => 'File, Block, and Object Storage Services for your Cloud-Native Environment',
'icon' => 'https://rook.io/images/rook-logo.svg',
'name' => 'rook-ceph',
'sources' => ['https://github.com/rook/rook'],
'version' => 'v1.5.8'
}
end
subject { service.execute }
context 'with a valid file' do
it { is_expected.to eq(expected) }
end
context 'without Chart.yaml' do
before do
expect_next_instances_of(Gem::Package::TarReader::Entry, 14) do |entry|
expect(entry).to receive(:full_name).exactly(:once).and_wrap_original do |m, *args|
m.call(*args) + '_suffix'
end
end
end
it { expect { subject }.to raise_error(described_class::ExtractionError, 'Chart.yaml not found within a directory') }
end
context 'with Chart.yaml at root' do
before do
expect_next_instances_of(Gem::Package::TarReader::Entry, 14) do |entry|
expect(entry).to receive(:full_name).exactly(:once).and_return('Chart.yaml')
end
end
it { expect { subject }.to raise_error(described_class::ExtractionError, 'Chart.yaml not found within a directory') }
end
context 'with an invalid YAML' do
before do
expect_next_instance_of(Gem::Package::TarReader::Entry) do |entry|
expect(entry).to receive(:read).and_return('{')
end
end
it { expect { subject }.to raise_error(described_class::ExtractionError, 'Error while parsing Chart.yaml: (<unknown>): did not find expected node content while parsing a flow node at line 2 column 1') }
end
context 'with a corrupted Chart.yaml of incorrect size' do
let(:helm_fixture_path) { expand_fixture_path('packages/helm/corrupted_chart.tgz') }
let(:expected_error_message) { 'Chart.yaml too big' }
before do
allow(Zlib::GzipReader).to receive(:new).and_return(Zlib::GzipReader.new(File.open(helm_fixture_path)))
end
it 'raises an error with the expected message' do
expect { subject }.to raise_error(::Packages::Helm::ExtractFileMetadataService::ExtractionError, expected_error_message)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Helm
class ProcessFileService
include Gitlab::Utils::StrongMemoize
include ExclusiveLeaseGuard
ExtractionError = Class.new(StandardError)
DEFAULT_LEASE_TIMEOUT = 1.hour.to_i
def initialize(channel, package_file)
@channel = channel
@package_file = package_file
end
def execute
raise ExtractionError, 'Helm chart was not processed - package_file is not set' unless package_file
try_obtain_lease do
temp_package.transaction do
rename_package_and_set_version
rename_package_file_and_set_metadata
cleanup_temp_package
end
end
end
private
attr_reader :channel, :package_file
def rename_package_and_set_version
package.update!(
name: metadata['name'],
version: metadata['version'],
status: :default
)
end
def rename_package_file_and_set_metadata
# Updating file_name updates the path where the file is stored.
# We must pass the file again so that CarrierWave can handle the update
package_file.update!(
file_name: file_name,
file: package_file.file,
package_id: package.id,
helm_file_metadatum_attributes: {
channel: channel,
metadata: metadata
}
)
end
def cleanup_temp_package
temp_package.destroy if package.id != temp_package.id
end
def temp_package
package_file.package
end
strong_memoize_attr :temp_package
def package
project_packages = package_file.package.project.packages
package = project_packages.with_package_type(:helm)
.with_name(metadata['name'])
.with_version(metadata['version'])
.not_pending_destruction
.last
package || temp_package
end
strong_memoize_attr :package
def metadata
::Packages::Helm::ExtractFileMetadataService.new(package_file).execute
end
strong_memoize_attr :metadata
def file_name
"#{metadata['name']}-#{metadata['version']}.tgz"
end
# used by ExclusiveLeaseGuard
def lease_key
"packages:helm:process_file_service:package_file:#{package_file.id}"
end
# used by ExclusiveLeaseGuard
def lease_timeout
DEFAULT_LEASE_TIMEOUT
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Helm::ProcessFileService, feature_category: :package_registry do
let(:package) { create(:helm_package, without_package_files: true, status: 'processing') }
let!(:package_file) { create(:helm_package_file, without_loaded_metadatum: true, package: package) }
let(:channel) { 'stable' }
let(:service) { described_class.new(channel, package_file) }
let(:expected) do
{
'apiVersion' => 'v2',
'description' => 'File, Block, and Object Storage Services for your Cloud-Native Environment',
'icon' => 'https://rook.io/images/rook-logo.svg',
'name' => 'rook-ceph',
'sources' => ['https://github.com/rook/rook'],
'version' => 'v1.5.8'
}
end
describe '#execute' do
subject(:execute) { service.execute }
context 'without a file' do
let(:package_file) { nil }
it 'returns error', :aggregate_failures do
expect { execute }
.to not_change { Packages::Package.count }
.and not_change { Packages::PackageFile.count }
.and not_change { Packages::Helm::FileMetadatum.count }
.and raise_error(Packages::Helm::ProcessFileService::ExtractionError, 'Helm chart was not processed - package_file is not set')
end
end
context 'with existing package' do
let!(:existing_package) { create(:helm_package, project: package.project, name: 'rook-ceph', version: 'v1.5.8') }
it 'reuses existing package', :aggregate_failures do
expect { execute }
.to change { Packages::Package.count }.from(2).to(1)
.and not_change { package.name }
.and not_change { package.version }
.and not_change { package.status }
.and not_change { Packages::PackageFile.count }
.and change { package_file.file_name }.from(package_file.file_name).to("#{expected['name']}-#{expected['version']}.tgz")
.and change { Packages::Helm::FileMetadatum.count }.from(1).to(2)
.and change { package_file.helm_file_metadatum }.from(nil)
expect { package.reload }
.to raise_error(ActiveRecord::RecordNotFound)
expect(package_file.helm_file_metadatum.channel).to eq(channel)
expect(package_file.helm_file_metadatum.metadata).to eq(expected)
end
context 'marked as pending_destruction' do
before do
existing_package.pending_destruction!
end
it 'reuses the processing package' do
expect { execute }
.to not_change { Packages::Package.count }
.and not_change { Packages::PackageFile.count }
.and change { Packages::Helm::FileMetadatum.count }.by(1)
end
end
end
context 'with a valid file' do
it 'processes file', :aggregate_failures do
expect { execute }
.to not_change { Packages::Package.count }
.and change { package.name }.from(package.name).to(expected['name'])
.and change { package.version }.from(package.version).to(expected['version'])
.and change { package.status }.from('processing').to('default')
.and not_change { Packages::PackageFile.count }
.and change { package_file.file_name }.from(package_file.file_name).to("#{expected['name']}-#{expected['version']}.tgz")
.and change { Packages::Helm::FileMetadatum.count }.by(1)
.and change { package_file.helm_file_metadatum }.from(nil)
expect(package_file.helm_file_metadatum.channel).to eq(channel)
expect(package_file.helm_file_metadatum.metadata).to eq(expected)
end
end
context 'without Chart.yaml' do
before do
expect_next_instances_of(Gem::Package::TarReader::Entry, 14) do |entry|
expect(entry).to receive(:full_name).exactly(:once).and_wrap_original do |m, *args|
m.call(*args) + '_suffix'
end
end
end
it { expect { execute }.to raise_error(Packages::Helm::ExtractFileMetadataService::ExtractionError, 'Chart.yaml not found within a directory') }
end
context 'with Chart.yaml at root' do
before do
expect_next_instances_of(Gem::Package::TarReader::Entry, 14) do |entry|
expect(entry).to receive(:full_name).exactly(:once).and_return('Chart.yaml')
end
end
it { expect { execute }.to raise_error(Packages::Helm::ExtractFileMetadataService::ExtractionError, 'Chart.yaml not found within a directory') }
end
context 'with an invalid YAML' do
before do
expect_next_instance_of(Gem::Package::TarReader::Entry) do |entry|
expect(entry).to receive(:read).and_return('{')
end
end
it { expect { execute }.to raise_error(Packages::Helm::ExtractFileMetadataService::ExtractionError, 'Error while parsing Chart.yaml: (<unknown>): did not find expected node content while parsing a flow node at line 2 column 1') }
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Npm
class CreatePackageService < ::Packages::CreatePackageService
include Gitlab::Utils::StrongMemoize
include ExclusiveLeaseGuard
PACKAGE_JSON_NOT_ALLOWED_FIELDS = %w[readme readmeFilename licenseText contributors exports].freeze
DEFAULT_LEASE_TIMEOUT = 1.hour.to_i
def execute
return error('Version is empty.', 400) if version.blank?
return error('Attachment data is empty.', 400) if attachment['data'].blank?
return error('Package already exists.', 403) if current_package_exists?
return error('Package protected.', 403) if current_package_protected?
return error('File is too large.', 400) if file_size_exceeded?
package = try_obtain_lease do
ApplicationRecord.transaction { create_npm_package! }
end
return error('Could not obtain package lease. Please try again.', 400) unless package
package
end
private
def create_npm_package!
package = create_package!(:npm, name: name, version: version)
::Packages::CreatePackageFileService.new(package, file_params).execute
::Packages::CreateDependencyService.new(package, package_dependencies).execute
::Packages::Npm::CreateTagService.new(package, dist_tag).execute
create_npm_metadatum!(package)
package
end
def create_npm_metadatum!(package)
package.create_npm_metadatum!(package_json: package_json)
rescue ActiveRecord::RecordInvalid => e
if package.npm_metadatum && package.npm_metadatum.errors.where(:package_json, :too_large).any? # rubocop: disable CodeReuse/ActiveRecord
Gitlab::ErrorTracking.track_exception(e, field_sizes: field_sizes_for_error_tracking)
end
raise
end
def current_package_exists?
project.packages
.npm
.with_name(name)
.with_version(version)
.not_pending_destruction
.exists?
end
def current_package_protected?
return false if Feature.disabled?(:packages_protected_packages, project)
user_project_authorization_access_level = current_user.max_member_access_for_project(project.id)
project.package_protection_rules.push_protected_from?(access_level: user_project_authorization_access_level, package_name: name, package_type: :npm)
end
def name
params[:name]
end
def version
params[:versions].each_key.first
end
strong_memoize_attr :version
def version_data
params[:versions][version]
end
def package_json
version_data.except(*PACKAGE_JSON_NOT_ALLOWED_FIELDS)
end
def dist_tag
params['dist-tags'].each_key.first
end
def package_file_name
"#{name}-#{version}.tgz"
end
strong_memoize_attr :package_file_name
def attachment
params['_attachments'][package_file_name]
end
strong_memoize_attr :attachment
# TODO (technical debt): Extract the package size calculation to its own component and unit test it separately.
def calculated_package_file_size
# This calculation is based on:
# 1. 4 chars in a Base64 encoded string are 3 bytes in the original string. Meaning 1 char is 0.75 bytes.
# 2. The encoded string may have 1 or 2 extra '=' chars used for padding. Each padding char means 1 byte less in the original string.
# Reference:
# - https://blog.aaronlenoir.com/2017/11/10/get-original-length-from-base-64-string/
# - https://en.wikipedia.org/wiki/Base64#Decoding_Base64_with_padding
encoded_data = attachment['data']
((encoded_data.length * 0.75) - encoded_data[-2..].count('=')).to_i
end
strong_memoize_attr :calculated_package_file_size
def file_params
{
file: CarrierWaveStringFile.new(Base64.decode64(attachment['data'])),
size: calculated_package_file_size,
file_sha1: version_data[:dist][:shasum],
file_name: package_file_name,
build: params[:build]
}
end
def package_dependencies
_version, versions_data = params[:versions].first
versions_data
end
def file_size_exceeded?
project.actual_limits.exceeded?(:npm_max_file_size, calculated_package_file_size)
end
# used by ExclusiveLeaseGuard
def lease_key
"packages:npm:create_package_service:packages:#{project.id}_#{name}_#{version}"
end
# used by ExclusiveLeaseGuard
def lease_timeout
DEFAULT_LEASE_TIMEOUT
end
def field_sizes
package_json.transform_values do |value|
value.to_s.size
end
end
strong_memoize_attr :field_sizes
def filtered_field_sizes
field_sizes.select do |_, size|
size >= ::Packages::Npm::Metadatum::MIN_PACKAGE_JSON_FIELD_SIZE_FOR_ERROR_TRACKING
end
end
strong_memoize_attr :filtered_field_sizes
def largest_fields
field_sizes
.sort_by { |a| a[1] }
.reverse[0..::Packages::Npm::Metadatum::NUM_FIELDS_FOR_ERROR_TRACKING - 1]
.to_h
end
strong_memoize_attr :largest_fields
def field_sizes_for_error_tracking
filtered_field_sizes.empty? ? largest_fields : filtered_field_sizes
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Npm::CreatePackageService, feature_category: :package_registry do
let(:service) { described_class.new(project, user, params) }
subject { service.execute }
describe '#execute' do
include ExclusiveLeaseHelpers
let_it_be(:namespace) { create(:namespace) }
let_it_be_with_reload(:project) { create(:project, namespace: namespace) }
let_it_be(:user) { project.owner }
let(:version) { '1.0.1' }
let(:params) do
Gitlab::Json.parse(fixture_file('packages/npm/payload.json')
.gsub('@root/npm-test', package_name)
.gsub('1.0.1', version)).with_indifferent_access
end
let(:package_name) { "@#{namespace.path}/my-app" }
let(:version_data) { params.dig('versions', version) }
let(:lease_key) { "packages:npm:create_package_service:packages:#{project.id}_#{package_name}_#{version}" }
shared_examples 'valid package' do
it 'creates a package' do
expect { subject }
.to change { Packages::Package.count }.by(1)
.and change { Packages::Package.npm.count }.by(1)
.and change { Packages::Tag.count }.by(1)
.and change { Packages::Npm::Metadatum.count }.by(1)
end
it_behaves_like 'assigns the package creator' do
let(:package) { subject }
end
it { is_expected.to be_valid }
it 'creates a package with name and version' do
package = subject
expect(package.name).to eq(package_name)
expect(package.version).to eq(version)
end
it { expect(subject.npm_metadatum.package_json).to eq(version_data) }
it { expect(subject.name).to eq(package_name) }
it { expect(subject.version).to eq(version) }
context 'with build info' do
let_it_be(:job) { create(:ci_build, user: user) }
let(:params) { super().merge(build: job) }
it_behaves_like 'assigns build to package'
it_behaves_like 'assigns status to package'
it 'creates a package file build info' do
expect { subject }.to change { Packages::PackageFileBuildInfo.count }.by(1)
end
end
context 'when the npm metadatum creation results in a size error' do
shared_examples 'a package json structure size too large error' do
it 'does not create the package' do
expect(Gitlab::ErrorTracking).to receive(:track_exception).with(
instance_of(ActiveRecord::RecordInvalid),
field_sizes: expected_field_sizes
)
expect { subject }.to raise_error(ActiveRecord::RecordInvalid, /structure is too large/)
.and not_change { Packages::Package.count }
.and not_change { Packages::Package.npm.count }
.and not_change { Packages::Tag.count }
.and not_change { Packages::Npm::Metadatum.count }
end
end
context 'when some of the field sizes are above the error tracking size' do
let(:package_json) do
params[:versions][version].except(*::Packages::Npm::CreatePackageService::PACKAGE_JSON_NOT_ALLOWED_FIELDS)
end
# Only the fields that exceed the field size limit should be passed to error tracking
let(:expected_field_sizes) do
{
'test' => ('test' * 10000).size,
'field2' => ('a' * (::Packages::Npm::Metadatum::MIN_PACKAGE_JSON_FIELD_SIZE_FOR_ERROR_TRACKING + 1)).size
}
end
before do
params[:versions][version][:test] = 'test' * 10000
params[:versions][version][:field1] =
'a' * (::Packages::Npm::Metadatum::MIN_PACKAGE_JSON_FIELD_SIZE_FOR_ERROR_TRACKING - 1)
params[:versions][version][:field2] =
'a' * (::Packages::Npm::Metadatum::MIN_PACKAGE_JSON_FIELD_SIZE_FOR_ERROR_TRACKING + 1)
end
it_behaves_like 'a package json structure size too large error'
end
context 'when all of the field sizes are below the error tracking size' do
let(:package_json) do
params[:versions][version].except(*::Packages::Npm::CreatePackageService::PACKAGE_JSON_NOT_ALLOWED_FIELDS)
end
let(:expected_size) { ('a' * (::Packages::Npm::Metadatum::MIN_PACKAGE_JSON_FIELD_SIZE_FOR_ERROR_TRACKING - 1)).size }
# Only the five largest fields should be passed to error tracking
let(:expected_field_sizes) do
{
'field1' => expected_size,
'field2' => expected_size,
'field3' => expected_size,
'field4' => expected_size,
'field5' => expected_size
}
end
before do
5.times do |i|
params[:versions][version]["field#{i + 1}"] =
'a' * (::Packages::Npm::Metadatum::MIN_PACKAGE_JSON_FIELD_SIZE_FOR_ERROR_TRACKING - 1)
end
end
it_behaves_like 'a package json structure size too large error'
end
end
context 'when the npm metadatum creation results in a different error' do
it 'does not track the error' do
error_message = 'boom'
invalid_npm_metadatum_error = ActiveRecord::RecordInvalid.new(
build(:npm_metadatum).tap do |metadatum|
metadatum.errors.add(:base, error_message)
end
)
allow_next_instance_of(::Packages::Package) do |package|
allow(package).to receive(:create_npm_metadatum!).and_raise(invalid_npm_metadatum_error)
end
expect(Gitlab::ErrorTracking).not_to receive(:track_exception)
expect { subject }.to raise_error(ActiveRecord::RecordInvalid, /#{error_message}/)
end
end
described_class::PACKAGE_JSON_NOT_ALLOWED_FIELDS.each do |field|
context "with not allowed #{field} field" do
before do
params[:versions][version][field] = 'test'
end
it 'is persisted without the field' do
expect { subject }
.to change { Packages::Package.count }.by(1)
.and change { Packages::Package.npm.count }.by(1)
.and change { Packages::Tag.count }.by(1)
.and change { Packages::Npm::Metadatum.count }.by(1)
expect(subject.npm_metadatum.package_json[field]).to be_blank
end
end
end
end
context 'scoped package' do
it_behaves_like 'valid package'
end
context 'when user is no project member' do
let_it_be(:user) { create(:user) }
it_behaves_like 'valid package'
end
context 'scoped package not following the naming convention' do
let(:package_name) { '@any-scope/package' }
it_behaves_like 'valid package'
end
context 'unscoped package' do
let(:package_name) { 'unscoped-package' }
it_behaves_like 'valid package'
end
context 'package already exists' do
let(:package_name) { "@#{namespace.path}/my_package" }
let!(:existing_package) { create(:npm_package, project: project, name: package_name, version: '1.0.1') }
it { expect(subject[:http_status]).to eq 403 }
it { expect(subject[:message]).to be 'Package already exists.' }
context 'marked as pending_destruction' do
before do
existing_package.pending_destruction!
end
it 'creates a new package' do
expect { subject }
.to change { Packages::Package.count }.by(1)
.and change { Packages::Package.npm.count }.by(1)
.and change { Packages::Tag.count }.by(1)
.and change { Packages::Npm::Metadatum.count }.by(1)
end
end
end
describe 'max file size validation' do
let(:max_file_size) { 5.bytes }
shared_examples_for 'max file size validation failure' do
it 'returns a 400 error', :aggregate_failures do
expect(subject[:http_status]).to eq 400
expect(subject[:message]).to be 'File is too large.'
end
end
before do
project.actual_limits.update!(npm_max_file_size: max_file_size)
end
context 'when max file size is exceeded' do
# NOTE: The base64 encoded package data in the fixture file is the "hello\n" string, whose byte size is 6.
it_behaves_like 'max file size validation failure'
end
context 'when file size is faked by setting the attachment length param to a lower size' do
let(:params) { super().deep_merge!({ _attachments: { "#{package_name}-#{version}.tgz" => { data: encoded_package_data, length: 1 } } }) }
# TODO (technical debt): Extract the package size calculation outside the service and add separate specs for it.
# Right now we have several contexts here to test the calculation's different scenarios.
context 'when encoded package data is not padded' do
# 'Hello!' (size = 6 bytes) => 'SGVsbG8h'
let(:encoded_package_data) { 'SGVsbG8h' }
it_behaves_like 'max file size validation failure'
end
context "when encoded package data is padded with '='" do
let(:max_file_size) { 4.bytes }
# 'Hello' (size = 5 bytes) => 'SGVsbG8='
let(:encoded_package_data) { 'SGVsbG8=' }
it_behaves_like 'max file size validation failure'
end
context "when encoded package data is padded with '=='" do
let(:max_file_size) { 3.bytes }
# 'Hell' (size = 4 bytes) => 'SGVsbA=='
let(:encoded_package_data) { 'SGVsbA==' }
it_behaves_like 'max file size validation failure'
end
end
end
context 'with invalid name' do
where(:package_name) do
[
'@inv@lid_scope/package',
'@scope/sub/group',
'@scope/../../package',
'@scope%2e%2e%2fpackage'
]
end
with_them do
it { expect { subject }.to raise_error(ActiveRecord::RecordInvalid) }
end
end
context 'with empty versions' do
let(:params) { super().merge!({ versions: {} }) }
it { expect(subject[:http_status]).to eq 400 }
it { expect(subject[:message]).to eq 'Version is empty.' }
end
context 'with invalid versions' do
where(:version) do
[
'1',
'1.2',
'1./2.3',
'../../../../../1.2.3',
'%2e%2e%2f1.2.3'
]
end
with_them do
it { expect { subject }.to raise_error(ActiveRecord::RecordInvalid, "Validation failed: Version #{Gitlab::Regex.semver_regex_message}") }
end
end
context 'with empty attachment data' do
let(:params) { super().merge({ _attachments: { "#{package_name}-#{version}.tgz" => { data: '' } } }) }
it { expect(subject[:http_status]).to eq 400 }
it { expect(subject[:message]).to eq 'Attachment data is empty.' }
end
it 'obtains a lease to create a new package' do
expect_to_obtain_exclusive_lease(lease_key, timeout: described_class::DEFAULT_LEASE_TIMEOUT)
subject
end
context 'when the lease is already taken' do
before do
stub_exclusive_lease_taken(lease_key, timeout: described_class::DEFAULT_LEASE_TIMEOUT)
end
it { expect(subject[:http_status]).to eq 400 }
it { expect(subject[:message]).to eq 'Could not obtain package lease. Please try again.' }
end
context 'when feature flag :packages_protected_packages disabled' do
let_it_be_with_reload(:package_protection_rule) { create(:package_protection_rule, package_type: :npm, project: project) }
before do
stub_feature_flags(packages_protected_packages: false)
end
context 'with matching package protection rule for all roles' do
using RSpec::Parameterized::TableSyntax
let(:package_name_pattern_no_match) { "#{package_name}_no_match" }
where(:package_name_pattern, :push_protected_up_to_access_level) do
ref(:package_name) | :developer
ref(:package_name) | :owner
ref(:package_name_pattern_no_match) | :developer
ref(:package_name_pattern_no_match) | :owner
end
with_them do
before do
package_protection_rule.update!(package_name_pattern: package_name_pattern, push_protected_up_to_access_level: push_protected_up_to_access_level)
end
it_behaves_like 'valid package'
end
end
end
context 'with package protection rule for different roles and package_name_patterns' do
using RSpec::Parameterized::TableSyntax
let_it_be_with_reload(:package_protection_rule) { create(:package_protection_rule, package_type: :npm, project: project) }
let_it_be(:project_developer) { create(:user).tap { |u| project.add_developer(u) } }
let_it_be(:project_maintainer) { create(:user).tap { |u| project.add_maintainer(u) } }
let(:project_owner) { project.owner }
let(:package_name_pattern_no_match) { "#{package_name}_no_match" }
let(:service) { described_class.new(project, current_user, params) }
shared_examples 'protected package' do
it { is_expected.to include http_status: 403, message: 'Package protected.' }
it 'does not create any npm-related package records' do
expect { subject }
.to not_change { Packages::Package.count }
.and not_change { Packages::Package.npm.count }
.and not_change { Packages::Tag.count }
.and not_change { Packages::Npm::Metadatum.count }
end
end
where(:package_name_pattern, :push_protected_up_to_access_level, :current_user, :shared_examples_name) do
ref(:package_name) | :developer | ref(:project_developer) | 'protected package'
ref(:package_name) | :developer | ref(:project_owner) | 'valid package'
ref(:package_name) | :maintainer | ref(:project_maintainer) | 'protected package'
ref(:package_name) | :owner | ref(:project_owner) | 'protected package'
ref(:package_name_pattern_no_match) | :developer | ref(:project_owner) | 'valid package'
ref(:package_name_pattern_no_match) | :owner | ref(:project_owner) | 'valid package'
end
with_them do
before do
package_protection_rule.update!(package_name_pattern: package_name_pattern, push_protected_up_to_access_level: push_protected_up_to_access_level)
end
it_behaves_like params[:shared_examples_name]
end
end
describe '#lease_key' do
subject { service.send(:lease_key) }
it 'returns an unique key' do
is_expected.to eq lease_key
end
end
end
context 'when many of the same packages are created at the same time', :delete do
let(:namespace) { create(:namespace) }
let(:project) { create(:project, namespace: namespace) }
let(:user) { project.owner }
let(:version) { '1.0.1' }
let(:params) do
Gitlab::Json.parse(
fixture_file('packages/npm/payload.json')
.gsub('@root/npm-test', package_name)
.gsub('1.0.1', version)
).with_indifferent_access
end
let(:package_name) { "@#{namespace.path}/my-app" }
let(:service) { described_class.new(project, user, params) }
subject { service.execute }
it 'only creates one package' do
expect { create_packages(project, user, params) }.to change { Packages::Package.count }.by(1)
end
context 'with different versions' do
it 'creates all packages' do
expect { create_packages_with_versions(project, user, params) }.to change { Packages::Package.count }.by(5)
end
end
def create_packages(project, user, params)
with_threads do
described_class.new(project, user, params).execute
end
end
def create_packages_with_versions(project, user, params)
with_threads do |i|
# Modify the package's version
modified_params = Gitlab::Json.parse(params.to_json
.gsub(version, "1.0.#{i}")).with_indifferent_access
described_class.new(project, user, modified_params).execute
end
end
def with_threads(count: 5, &block)
return unless block
# create a race condition - structure from https://blog.arkency.com/2015/09/testing-race-conditions/
wait_for_it = true
threads = Array.new(count) do |i|
Thread.new do
# A loop to make threads busy until we `join` them
true while wait_for_it
yield(i)
end
end
wait_for_it = false
threads.each(&:join)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Npm
class GenerateMetadataService
include API::Helpers::RelatedResourcesHelpers
include Gitlab::Utils::StrongMemoize
# Allowed fields are those defined in the abbreviated form
# defined here: https://github.com/npm/registry/blob/master/docs/responses/package-metadata.md#abbreviated-version-object
# except: name, version, dist, dependencies and xDependencies. Those are generated by this service.
PACKAGE_JSON_ALLOWED_FIELDS = %w[deprecated bin directories dist engines _hasShrinkwrap].freeze
def initialize(name, packages)
@name = name
@packages = packages
@dependencies = {}
@dependency_ids = Hash.new { |h, key| h[key] = {} }
end
def execute(only_dist_tags: false)
ServiceResponse.success(payload: metadata(only_dist_tags))
end
private
attr_reader :name, :packages, :dependencies, :dependency_ids
def metadata(only_dist_tags)
result = { dist_tags: dist_tags }
unless only_dist_tags
result[:name] = name
result[:versions] = versions
end
result
end
def versions
package_versions = {}
packages.each_batch do |relation|
load_dependencies(relation)
load_dependency_ids(relation)
batched_packages = relation.preload_files
.preload_npm_metadatum
batched_packages.each do |package|
package_file = package.installable_package_files.last
next unless package_file
package_versions[package.version] = build_package_version(package, package_file)
end
end
package_versions
end
def dist_tags
build_package_tags.tap { |t| t['latest'] ||= sorted_versions.last }
end
def build_package_tags
package_tags.to_h { |tag| [tag.name, tag.package.version] }
end
def build_package_version(package, package_file)
abbreviated_package_json(package).merge(
name: package.name,
version: package.version,
dist: {
shasum: package_file.file_sha1,
tarball: tarball_url(package, package_file)
}
).tap do |package_version|
package_version.merge!(build_package_dependencies(package))
end
end
def tarball_url(package, package_file)
expose_url api_v4_projects_packages_npm_package_name___file_name_path(
{ id: package.project_id, package_name: package.name, file_name: package_file.file_name }, true
)
end
def build_package_dependencies(package)
dependency_ids[package.id].each_with_object(Hash.new { |h, key| h[key] = {} }) do |(type, ids), memo|
ids.each do |id|
memo[inverted_dependency_types[type]].merge!(dependencies[id])
end
end
end
def inverted_dependency_types
Packages::DependencyLink.dependency_types.invert.stringify_keys
end
strong_memoize_attr :inverted_dependency_types
def sorted_versions
versions = packages.pluck_versions.compact
VersionSorter.sort(versions)
end
def package_tags
Packages::Tag.for_package_ids(packages)
.preload_package
end
def abbreviated_package_json(package)
json = package.npm_metadatum&.package_json || {}
json.slice(*PACKAGE_JSON_ALLOWED_FIELDS)
end
def load_dependencies(packages)
Packages::Dependency
.id_in(
Packages::DependencyLink
.for_packages(packages)
.select_dependency_id
)
.id_not_in(dependencies.keys)
.each_batch do |relation|
relation.each do |dependency|
dependencies[dependency.id] = { dependency.name => dependency.version_pattern }
end
end
end
def load_dependency_ids(packages)
Packages::DependencyLink
.dependency_ids_grouped_by_type(packages)
.each_batch(column: :package_id) do |relation|
relation.each do |dependency_link|
dependency_ids[dependency_link.package_id] = dependency_link.dependency_ids_by_type
end
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe ::Packages::Npm::GenerateMetadataService, feature_category: :package_registry do
using RSpec::Parameterized::TableSyntax
let_it_be(:project) { create(:project) }
let_it_be(:package_name) { "@#{project.root_namespace.path}/test" }
let_it_be(:package1) { create(:npm_package, version: '2.0.4', project: project, name: package_name) }
let_it_be(:package2) { create(:npm_package, version: '2.0.6', project: project, name: package_name) }
let_it_be(:latest_package) { create(:npm_package, version: '2.0.11', project: project, name: package_name) }
let(:packages) { project.packages.npm.with_name(package_name) }
let(:metadata) { described_class.new(package_name, packages).execute }
describe '#versions' do
let_it_be(:version_schema) { 'public_api/v4/packages/npm_package_version' }
let_it_be(:package_json) do
{
name: package_name,
version: '2.0.4',
deprecated: 'warning!',
bin: './cli.js',
directories: ['lib'],
engines: { npm: '^7.5.6' },
_hasShrinkwrap: false,
dist: {
tarball: 'http://localhost/tarball.tgz',
shasum: '1234567890'
},
custom_field: 'foo_bar'
}
end
subject { metadata[:versions] }
where(:has_dependencies, :has_metadatum) do
true | true
false | true
true | false
false | false
end
with_them do
if params[:has_dependencies]
::Packages::DependencyLink.dependency_types.each_key do |dependency_type| # rubocop:disable RSpec/UselessDynamicDefinition -- `dependency_type` used in `let_it_be`
let_it_be("package_dependency_link_for_#{dependency_type}") do
create(:packages_dependency_link, package: package1, dependency_type: dependency_type)
end
end
end
if params[:has_metadatum]
let_it_be(:package_metadatadum) { create(:npm_metadatum, package: package1, package_json: package_json) }
end
it { is_expected.to be_a(Hash) }
it { expect(subject[package1.version].with_indifferent_access).to match_schema(version_schema) }
it { expect(subject[package2.version].with_indifferent_access).to match_schema(version_schema) }
it { expect(subject[package1.version]['custom_field']).to be_blank }
context 'for dependencies' do
::Packages::DependencyLink.dependency_types.each_key do |dependency_type|
if params[:has_dependencies]
it { expect(subject.dig(package1.version, dependency_type.to_s)).to be_any }
else
it { expect(subject.dig(package1.version, dependency_type)).to be nil }
end
it { expect(subject.dig(package2.version, dependency_type)).to be nil }
end
context 'when generate dependencies' do
let(:packages) { ::Packages::Package.where(id: package1.id) }
it 'loads grouped dependency links', :aggregate_failures do
expect(::Packages::DependencyLink).to receive(:dependency_ids_grouped_by_type).and_call_original
expect(::Packages::Package).not_to receive(:including_dependency_links)
subject
end
end
end
context 'for metadatum' do
::Packages::Npm::GenerateMetadataService::PACKAGE_JSON_ALLOWED_FIELDS.each do |metadata_field|
if params[:has_metadatum]
it { expect(subject.dig(package1.version, metadata_field)).not_to be nil }
else
it { expect(subject.dig(package1.version, metadata_field)).to be nil }
end
it { expect(subject.dig(package2.version, metadata_field)).to be nil }
end
end
it 'avoids N+1 database queries' do
check_n_plus_one do
create_list(:npm_package, 5, project: project, name: package_name).each do |npm_package|
next unless has_dependencies
::Packages::DependencyLink.dependency_types.each_key do |dependency_type|
create(:packages_dependency_link, package: npm_package, dependency_type: dependency_type)
end
end
end
end
end
context 'with package files pending destruction' do
let_it_be(:package_file_pending_destruction) do
create(:package_file, :pending_destruction, package: package2, file_sha1: 'pending_destruction_sha1')
end
let(:shasums) { subject.values.map { |v| v.dig(:dist, :shasum) } }
it 'does not return them' do
expect(shasums).not_to include(package_file_pending_destruction.file_sha1)
end
end
end
describe '#dist_tags' do
subject { metadata[:dist_tags] }
context 'for packages without tags' do
it { is_expected.to be_a(Hash) }
it { expect(subject['latest']).to eq(latest_package.version) }
it 'avoids N+1 database queries' do
check_n_plus_one(only_dist_tags: true) do
create_list(:npm_package, 5, project: project, name: package_name)
end
end
end
context 'for packages with tags' do
let_it_be(:package_tag1) { create(:packages_tag, package: package1, name: 'release_a') }
let_it_be(:package_tag2) { create(:packages_tag, package: package1, name: 'test_release') }
let_it_be(:package_tag3) { create(:packages_tag, package: package2, name: 'release_b') }
let_it_be(:package_tag4) { create(:packages_tag, package: latest_package, name: 'release_c') }
let_it_be(:package_tag5) { create(:packages_tag, package: latest_package, name: 'latest') }
it { is_expected.to be_a(Hash) }
it { expect(subject[package_tag1.name]).to eq(package1.version) }
it { expect(subject[package_tag2.name]).to eq(package1.version) }
it { expect(subject[package_tag3.name]).to eq(package2.version) }
it { expect(subject[package_tag4.name]).to eq(latest_package.version) }
it { expect(subject[package_tag5.name]).to eq(latest_package.version) }
it 'avoids N+1 database queries' do
check_n_plus_one(only_dist_tags: true) do
create_list(:npm_package, 5, project: project, name: package_name).each_with_index do |npm_package, index|
create(:packages_tag, package: npm_package, name: "tag_#{index}")
end
end
end
end
end
context 'when passing only_dist_tags: true' do
subject { described_class.new(package_name, packages).execute(only_dist_tags: true) }
it 'returns only dist tags' do
expect(subject.payload.keys).to contain_exactly(:dist_tags)
end
end
def check_n_plus_one(only_dist_tags: false)
pkgs = project.packages.npm.with_name(package_name).preload_files
control = ActiveRecord::QueryRecorder.new do
described_class.new(package_name, pkgs).execute(only_dist_tags: only_dist_tags)
end
yield
pkgs = project.packages.npm.with_name(package_name).preload_files
expect do
described_class.new(package_name, pkgs).execute(only_dist_tags: only_dist_tags)
end.not_to exceed_query_limit(control)
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Npm
class DeprecatePackageService < BaseService
Deprecated = Struct.new(:package_id, :message)
BATCH_SIZE = 50
def initialize(project, params)
super(project, nil, params)
end
def execute(async: false)
return ::Packages::Npm::DeprecatePackageWorker.perform_async(project.id, filtered_params) if async
packages.select(:id, :version).each_batch(of: BATCH_SIZE) do |relation|
deprecated_metadatum = handle_batch(relation)
update_metadatum(deprecated_metadatum)
end
end
private
# To avoid passing the whole metadata to the worker
def filtered_params
{
package_name: params[:package_name],
versions: params[:versions].transform_values { |version| version.slice(:deprecated) }
}
end
def packages
::Packages::Npm::PackageFinder
.new(params['package_name'], project: project)
.execute
end
def handle_batch(relation)
relation
.preload_npm_metadatum
.filter_map { |package| deprecate(package) }
end
def deprecate(package)
deprecation_message = params.dig('versions', package.version, 'deprecated')
return if deprecation_message.nil?
npm_metadatum = package.npm_metadatum
return if identical?(npm_metadatum.package_json['deprecated'], deprecation_message)
Deprecated.new(npm_metadatum.package_id, deprecation_message)
end
def identical?(package_json_deprecated, deprecation_message)
package_json_deprecated == deprecation_message ||
(package_json_deprecated.nil? && deprecation_message.empty?)
end
def update_metadatum(deprecated_metadatum)
return if deprecated_metadatum.empty?
deprecation_message = deprecated_metadatum.first.message
::Packages::Npm::Metadatum
.package_id_in(deprecated_metadatum.map(&:package_id))
.update_all(update_clause(deprecation_message))
end
def update_clause(deprecation_message)
if deprecation_message.empty?
"package_json = package_json - 'deprecated'"
else
["package_json = jsonb_set(package_json, '{deprecated}', ?)", deprecation_message.to_json]
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Npm::DeprecatePackageService, feature_category: :package_registry do
let_it_be(:namespace) { create(:namespace) }
let_it_be(:project) { create(:project, namespace: namespace) }
let_it_be(:package_name) { "@#{namespace.path}/my-app" }
let_it_be_with_reload(:package_1) do
create(:npm_package, project: project, name: package_name, version: '1.0.1').tap do |package|
create(:npm_metadatum, package: package)
end
end
let_it_be(:package_2) do
create(:npm_package, project: project, name: package_name, version: '1.0.2').tap do |package|
create(:npm_metadatum, package: package)
end
end
let(:service) { described_class.new(project, params) }
subject(:execute) { service.execute }
describe '#execute' do
context 'when passing deprecatation message' do
let(:params) do
{
'package_name' => package_name,
'versions' => {
'1.0.1' => {
'name' => package_name,
'deprecated' => 'This version is deprecated'
},
'1.0.2' => {
'name' => package_name,
'deprecated' => 'This version is deprecated'
}
}
}
end
before do
package_json = package_2.npm_metadatum.package_json
package_2.npm_metadatum.update!(package_json: package_json.merge('deprecated' => 'old deprecation message'))
end
it 'adds or updates the deprecated field' do
expect { execute }
.to change { package_1.reload.npm_metadatum.package_json['deprecated'] }.to('This version is deprecated')
.and change { package_2.reload.npm_metadatum.package_json['deprecated'] }
.from('old deprecation message').to('This version is deprecated')
end
it 'executes 5 queries' do
queries = ActiveRecord::QueryRecorder.new do
execute
end
# 1. each_batch lower bound
# 2. each_batch upper bound
# 3. SELECT packages_packages.id, packages_packages.version FROM packages_packages
# 4. SELECT packages_npm_metadata.* FROM packages_npm_metadata
# 5. UPDATE packages_npm_metadata SET package_json =
expect(queries.count).to eq(5)
end
end
context 'when passing deprecated as empty string' do
let(:params) do
{
'package_name' => package_name,
'versions' => {
'1.0.1' => {
'name' => package_name,
'deprecated' => ''
}
}
}
end
before do
package_json = package_1.npm_metadatum.package_json
package_1.npm_metadatum.update!(package_json: package_json.merge('deprecated' => 'This version is deprecated'))
end
it 'removes the deprecation warning' do
expect { execute }
.to change { package_1.reload.npm_metadatum.package_json['deprecated'] }
.from('This version is deprecated').to(nil)
end
end
context 'when passing async: true to execute' do
let(:params) do
{
package_name: package_name,
versions: {
'1.0.1': {
deprecated: 'This version is deprecated'
}
}
}
end
it 'calls the worker and return' do
expect(::Packages::Npm::DeprecatePackageWorker).to receive(:perform_async).with(project.id, params)
expect(service).not_to receive(:packages)
service.execute(async: true)
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Npm
class CreateMetadataCacheService
include Gitlab::Utils::StrongMemoize
include ExclusiveLeaseGuard
# used by ExclusiveLeaseGuard
DEFAULT_LEASE_TIMEOUT = 1.hour.to_i.freeze
def initialize(project, package_name)
@project = project
@package_name = package_name
end
def execute
try_obtain_lease do
Packages::Npm::MetadataCache
.find_or_build(package_name: package_name, project_id: project.id)
.update!(
file: CarrierWaveStringFile.new(metadata_content),
size: metadata_content.bytesize
)
end
end
private
attr_reader :package_name, :project
def metadata_content
::API::Entities::NpmPackage.represent(metadata.payload).to_json
end
strong_memoize_attr :metadata_content
def packages
::Packages::Npm::PackageFinder
.new(package_name, project: project)
.execute
end
def metadata
Packages::Npm::GenerateMetadataService.new(package_name, packages).execute
end
# used by ExclusiveLeaseGuard
def lease_key
"packages:npm:create_metadata_cache_service:metadata_caches:#{project.id}_#{package_name}"
end
# used by ExclusiveLeaseGuard
def lease_timeout
DEFAULT_LEASE_TIMEOUT
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Npm::CreateMetadataCacheService, :clean_gitlab_redis_shared_state, feature_category: :package_registry do
include ExclusiveLeaseHelpers
let_it_be(:project) { create(:project) }
let_it_be(:package_name) { "@#{project.root_namespace.path}/npm-test" }
let_it_be(:package) { create(:npm_package, version: '1.0.0', project: project, name: package_name) }
let(:lease_key) { "packages:npm:create_metadata_cache_service:metadata_caches:#{project.id}_#{package_name}" }
let(:service) { described_class.new(project, package_name) }
describe '#execute' do
let(:npm_metadata_cache) { Packages::Npm::MetadataCache.last }
subject { service.execute }
it 'creates a new metadata cache', :aggregate_failures do
expect { subject }.to change { Packages::Npm::MetadataCache.count }.by(1)
metadata = Gitlab::Json.parse(npm_metadata_cache.file.read)
expect(npm_metadata_cache.package_name).to eq(package_name)
expect(npm_metadata_cache.project_id).to eq(project.id)
expect(npm_metadata_cache.size).to eq(metadata.to_json.bytesize)
expect(metadata['name']).to eq(package_name)
expect(metadata['versions'].keys).to contain_exactly('1.0.0')
end
context 'with existing metadata cache' do
let_it_be(:npm_metadata_cache) { create(:npm_metadata_cache, package_name: package_name, project_id: project.id) }
let_it_be(:metadata) { Gitlab::Json.parse(npm_metadata_cache.file.read) }
let_it_be(:metadata_size) { npm_metadata_cache.size }
let_it_be(:tag_name) { 'new-tag' }
let_it_be(:tag) { create(:packages_tag, package: package, name: tag_name) }
it 'does not create a new metadata cache' do
expect { subject }.to change { Packages::Npm::MetadataCache.count }.by(0)
end
it 'updates the metadata cache', :aggregate_failures do
subject
new_metadata = Gitlab::Json.parse(npm_metadata_cache.file.read)
expect(new_metadata).not_to eq(metadata)
expect(new_metadata['dist-tags'].keys).to include(tag_name)
expect(npm_metadata_cache.reload.size).not_to eq(metadata_size)
end
end
it 'obtains a lease to create a new metadata cache' do
expect_to_obtain_exclusive_lease(lease_key, timeout: described_class::DEFAULT_LEASE_TIMEOUT)
subject
end
context 'when the lease is already taken' do
before do
stub_exclusive_lease_taken(lease_key, timeout: described_class::DEFAULT_LEASE_TIMEOUT)
end
it 'does not create a new metadata cache' do
expect { subject }.to change { Packages::Npm::MetadataCache.count }.by(0)
end
it 'returns nil' do
expect(subject).to be_nil
end
end
end
describe '#lease_key' do
subject { service.send(:lease_key) }
it 'returns an unique key' do
is_expected.to eq lease_key
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Packages
module Npm
class CreateTagService
include Gitlab::Utils::StrongMemoize
attr_reader :package, :tag_name
def initialize(package, tag_name)
@package = package
@tag_name = tag_name
end
def execute
if existing_tag.present?
existing_tag.update_column(:package_id, package.id)
existing_tag
else
package.tags.create!(name: tag_name)
end
end
private
def existing_tag
Packages::TagsFinder
.new(package.project, package.name, package_type: package.package_type)
.find_by_name(tag_name)
end
strong_memoize_attr :existing_tag
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Packages::Npm::CreateTagService, feature_category: :package_registry do
let(:package) { create(:npm_package) }
let(:tag_name) { 'test-tag' }
describe '#execute' do
subject { described_class.new(package, tag_name).execute }
shared_examples 'it creates the tag' do
it { expect { subject }.to change { Packages::Tag.count }.by(1) }
it { expect(subject.name).to eq(tag_name) }
it 'adds tag to the package' do
tag = subject
expect(package.reload.tags).to match_array([tag])
end
end
context 'with no existing tag name' do
it_behaves_like 'it creates the tag'
end
context 'with exisiting tag name' do
let!(:package_tag2) { create(:packages_tag, package: package2, name: tag_name) }
context 'on package with different name' do
let!(:package2) { create(:npm_package, project: package.project) }
it_behaves_like 'it creates the tag'
end
context 'on different package type' do
let!(:package2) { create(:conan_package, project: package.project, name: 'conan_package_name', version: package.version) }
it_behaves_like 'it creates the tag'
end
context 'on same package with different version' do
let!(:package2) { create(:npm_package, project: package.project, name: package.name, version: '5.0.0-testing') }
it { expect { subject }.to not_change { Packages::Tag.count } }
it { expect(subject.name).to eq(tag_name) }
it 'adds tag to the package' do
tag = subject
expect(package.reload.tags).to match_array([tag])
expect(package2.reload.tags).to be_empty
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Boards
class DestroyService < Boards::BaseService
def execute(board)
board.destroy!
ServiceResponse.success
end
private
def boards
parent.boards
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Boards::DestroyService, feature_category: :team_planning do
context 'with project board' do
let_it_be(:parent) { create(:project) }
let(:boards) { parent.boards }
let(:board_factory) { :board }
it_behaves_like 'board destroy service'
end
context 'with group board' do
let_it_be(:parent) { create(:group) }
let(:boards) { parent.boards }
let(:board_factory) { :board }
it_behaves_like 'board destroy service'
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Boards
class CreateService < Boards::BaseService
def execute
unless can_create_board?
return ServiceResponse.error(message: "You don't have the permission to create a board for this resource.")
end
create_board!
end
private
def can_create_board?
parent_board_collection.empty? || parent.multiple_issue_boards_available?
end
def create_board!
board = parent_board_collection.create(params)
unless board.persisted?
return ServiceResponse.error(message: "There was an error when creating a board.", payload: board)
end
board.tap do |created_board|
created_board.lists.create(list_type: :backlog)
created_board.lists.create(list_type: :closed)
end
ServiceResponse.success(payload: board)
end
def parent_board_collection
parent.boards
end
end
end
Boards::CreateService.prepend_mod_with('Boards::CreateService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Boards::CreateService, feature_category: :team_planning do
describe '#execute' do
context 'when board parent is a project' do
let(:parent) { create(:project) }
subject(:service) { described_class.new(parent, double) }
it_behaves_like 'boards create service'
end
context 'when board parent is a group' do
let(:parent) { create(:group) }
subject(:service) { described_class.new(parent, double) }
it_behaves_like 'boards create service'
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Boards
module Lists
class MoveService < Boards::BaseService
def execute(list)
@board = list.board
@old_position = list.position
@new_position = params[:position]
return false unless list.movable?
return false unless valid_move?
list.with_lock do
reorder_intermediate_lists
update_list_position(list)
end
end
private
attr_reader :board, :old_position, :new_position
def valid_move?
new_position.present? && new_position != old_position && new_position.between?(0, max_position)
end
def max_position
board.lists.movable.maximum(:position)
end
def reorder_intermediate_lists
if old_position < new_position
decrement_intermediate_lists
else
increment_intermediate_lists
end
end
# rubocop: disable CodeReuse/ActiveRecord
def decrement_intermediate_lists
board.lists.movable.where('position > ?', old_position)
.where('position <= ?', new_position)
.update_all('position = position - 1')
end
# rubocop: enable CodeReuse/ActiveRecord
# rubocop: disable CodeReuse/ActiveRecord
def increment_intermediate_lists
board.lists.movable.where('position >= ?', new_position)
.where('position < ?', old_position)
.update_all('position = position + 1')
end
# rubocop: enable CodeReuse/ActiveRecord
def update_list_position(list)
list.update_attribute(:position, new_position)
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Boards::Lists::MoveService, feature_category: :team_planning do
describe '#execute' do
context 'when board parent is a project' do
let(:project) { create(:project) }
let(:board) { create(:board, project: project) }
let(:user) { create(:user) }
let(:parent) { project }
it_behaves_like 'lists move service'
end
context 'when board parent is a group' do
let(:group) { create(:group) }
let(:board) { create(:board, group: group) }
let(:user) { create(:user) }
let(:parent) { group }
it_behaves_like 'lists move service'
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Boards
module Lists
# overridden in EE for board lists and also for epic board lists.
class DestroyService < Boards::Lists::BaseDestroyService
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Boards::Lists::DestroyService, feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let(:list_type) { :list }
describe '#execute' do
context 'when board parent is a project' do
let_it_be(:project) { create(:project) }
let_it_be(:board) { create(:board, project: project) }
let_it_be(:list) { create(:list, board: board) }
let_it_be(:closed_list) { board.lists.closed.first }
let(:params) do
{ board: board }
end
let(:parent) { project }
it_behaves_like 'lists destroy service'
end
context 'when board parent is a group' do
let_it_be(:group) { create(:group) }
let_it_be(:board) { create(:board, group: group) }
let_it_be(:list) { create(:list, board: board) }
let_it_be(:closed_list) { board.lists.closed.first }
let(:params) do
{ board: board }
end
let(:parent) { group }
it_behaves_like 'lists destroy service'
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Boards
module Lists
class UpdateService < Boards::Lists::BaseUpdateService
def can_read?(list)
Ability.allowed?(current_user, :read_issue_board_list, parent)
end
def can_admin?(list)
Ability.allowed?(current_user, :admin_issue_board_list, parent)
end
end
end
end
Boards::Lists::UpdateService.prepend_mod_with('Boards::Lists::UpdateService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Boards::Lists::UpdateService, feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let!(:list) { create(:list, board: board, position: 0) }
let!(:list2) { create(:list, board: board, position: 1) }
describe '#execute' do
let(:service) { described_class.new(board.resource_parent, user, params) }
context 'when position parameter is present' do
let(:params) { { position: 1 } }
context 'for projects' do
let(:project) { create(:project, :private) }
let(:board) { create(:board, project: project) }
it_behaves_like 'moving list'
end
context 'for groups' do
let(:group) { create(:group, :private) }
let(:board) { create(:board, group: group) }
it_behaves_like 'moving list'
end
end
context 'when collapsed parameter is present' do
let(:params) { { collapsed: true } }
context 'for projects' do
let(:project) { create(:project, :private) }
let(:board) { create(:board, project: project) }
it_behaves_like 'updating list preferences'
end
context 'for groups' do
let(:project) { create(:project, :private) }
let(:board) { create(:board, project: project) }
it_behaves_like 'updating list preferences'
end
end
context 'when position and collapsed are both present' do
let(:params) { { collapsed: true, position: 1 } }
context 'for projects' do
let(:project) { create(:project, :private) }
let(:board) { create(:board, project: project) }
it_behaves_like 'moving list'
it_behaves_like 'updating list preferences'
end
context 'for groups' do
let(:group) { create(:group, :private) }
let(:board) { create(:board, group: group) }
it_behaves_like 'moving list'
it_behaves_like 'updating list preferences'
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Boards
module Lists
class ListService < Boards::BaseService
def execute(board, create_default_lists: true)
if create_default_lists && !board.lists.backlog.exists?
board.lists.create(list_type: :backlog)
end
lists = board.lists.preload_associated_models
lists = lists.with_types(available_list_types_for(board))
return lists.id_in(params[:list_id]) if params[:list_id].present?
lists
end
private
def available_list_types_for(board)
licensed_list_types(board) + visible_lists(board)
end
def licensed_list_types(board)
[List.list_types[:label]]
end
def visible_lists(board)
[].tap do |visible|
visible << ::List.list_types[:backlog] unless board.hide_backlog_list?
visible << ::List.list_types[:closed] unless board.hide_closed_list?
end
end
end
end
end
Boards::Lists::ListService.prepend_mod_with('Boards::Lists::ListService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Boards::Lists::ListService, feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let_it_be(:group) { create(:group) }
RSpec.shared_examples 'FOSS lists only' do
context 'when board contains a non FOSS list' do
# This scenario may happen when there used to be an EE license and user downgraded
let_it_be(:backlog_list) { board.lists.backlog.first }
let_it_be(:milestone) { create(:milestone, group: group) }
let_it_be(:assignee_list) do
list = build(:list, board: board, user_id: user.id, list_type: List.list_types[:assignee], position: 0)
list.save!(validate: false)
list
end
let_it_be(:milestone_list) do
list = build(:list, board: board, milestone_id: milestone.id, list_type: List.list_types[:milestone], position: 1) # rubocop:disable Layout/LineLength
list.save!(validate: false)
list
end
it "returns only FOSS board's lists" do
# just making sure these non FOSS lists actually exist on the board
expect(board.lists.with_types([List.list_types[:assignee], List.list_types[:milestone]]).count).to eq 2
# check that the FOSS lists are not returned from the service
expect(service.execute(board)).to match_array [backlog_list, list, board.lists.closed.first]
end
end
end
describe '#execute' do
let(:service) { described_class.new(parent, user) }
context 'when board parent is a project' do
let_it_be(:project) { create(:project, group: group) }
let_it_be_with_reload(:board) { create(:board, project: project) }
let_it_be(:label) { create(:label, project: project) }
let_it_be(:list) { create(:list, board: board, label: label) }
let_it_be(:unrelated_list) { create(:list) }
let(:parent) { project }
it_behaves_like 'lists list service'
it_behaves_like 'FOSS lists only'
end
context 'when board parent is a group' do
let_it_be_with_reload(:board) { create(:board, group: group) }
let_it_be(:label) { create(:group_label, group: group) }
let_it_be(:list) { create(:list, board: board, label: label) }
let_it_be(:unrelated_list) { create(:list) }
let(:parent) { group }
it_behaves_like 'lists list service'
it_behaves_like 'FOSS lists only'
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Boards
module Lists
class CreateService < Boards::Lists::BaseCreateService
end
end
end
Boards::Lists::CreateService.prepend_mod_with('Boards::Lists::CreateService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Boards::Lists::CreateService, feature_category: :team_planning do
context 'when board parent is a project' do
let_it_be(:parent) { create(:project) }
let_it_be(:board) { create(:board, project: parent) }
let_it_be(:label) { create(:label, project: parent, name: 'in-progress') }
it_behaves_like 'board lists create service'
end
context 'when board parent is a group' do
let_it_be(:parent) { create(:group) }
let_it_be(:board) { create(:board, group: parent) }
let_it_be(:label) { create(:group_label, group: parent, name: 'in-progress') }
it_behaves_like 'board lists create service'
end
def create_list(params)
create(:list, params.merge(board: board))
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Boards
module Visits
class CreateService < Boards::BaseService
def execute(board)
return unless current_user && Gitlab::Database.read_write?
return unless board
model.visited!(current_user, board)
end
private
def model
return BoardGroupRecentVisit if parent.is_a?(Group)
BoardProjectRecentVisit
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Boards::Visits::CreateService, feature_category: :team_planning do
describe '#execute' do
let(:user) { create(:user) }
context 'when a project board' do
let_it_be(:project) { create(:project) }
let_it_be(:board) { create(:board, project: project) }
let_it_be(:model) { BoardProjectRecentVisit }
it_behaves_like 'boards recent visit create service'
end
context 'when a group board' do
let_it_be(:group) { create(:group) }
let_it_be(:board) { create(:board, group: group) }
let_it_be(:model) { BoardGroupRecentVisit }
it_behaves_like 'boards recent visit create service'
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Boards
module Issues
class MoveService < Boards::BaseItemMoveService
def execute_multiple(issues)
return execute_multiple_empty_result if issues.empty?
handled_issues = []
last_inserted_issue_id = nil
count = issues.each.inject(0) do |moved_count, issue|
issue_modification_params = issuable_params(issue)
next moved_count if issue_modification_params.empty?
if last_inserted_issue_id
issue_modification_params[:move_between_ids] = move_below(last_inserted_issue_id)
end
last_inserted_issue_id = issue.id
handled_issue = move_single_issuable(issue, issue_modification_params)
handled_issues << present_issue_entity(handled_issue) if handled_issue
handled_issue && handled_issue.valid? ? moved_count + 1 : moved_count
end
{
count: count,
success: count == issues.size,
issues: handled_issues
}
end
private
def present_issue_entity(issue)
::API::Entities::Issue.represent(issue)
end
def execute_multiple_empty_result
@execute_multiple_empty_result ||= {
count: 0,
success: false,
issues: []
}
end
def move_below(id)
move_between_ids({ move_after_id: nil, move_before_id: id })
end
def board
@board ||= parent.boards.find(params[:board_id])
end
def update(issue, issue_modification_params)
::Issues::UpdateService.new(container: issue.project, current_user: current_user, params: issue_modification_params).execute(issue)
end
def moving_to_list_items_relation
Boards::Issues::ListService.new(board.resource_parent, current_user, board_id: board.id, id: moving_to_list.id).execute
end
end
end
end
Boards::Issues::MoveService.prepend_mod_with('Boards::Issues::MoveService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Boards::Issues::MoveService, feature_category: :team_planning do
describe '#execute' do
context 'when parent is a project' do
let(:user) { create(:user) }
let(:project) { create(:project) }
let(:board1) { create(:board, project: project) }
let(:board2) { create(:board, project: project) }
let(:bug) { create(:label, project: project, name: 'Bug') }
let(:development) { create(:label, project: project, name: 'Development') }
let(:testing) { create(:label, project: project, name: 'Testing') }
let(:regression) { create(:label, project: project, name: 'Regression') }
let!(:list1) { create(:list, board: board1, label: development, position: 0) }
let!(:list2) { create(:list, board: board1, label: testing, position: 1) }
let!(:closed) { create(:closed_list, board: board1) }
let(:parent) { project }
before do
parent.add_developer(user)
end
it_behaves_like 'issues move service'
end
context 'when parent is a group' do
let(:user) { create(:user) }
let(:group) { create(:group) }
let(:project) { create(:project, namespace: group) }
let(:board1) { create(:board, group: group) }
let(:board2) { create(:board, group: group) }
let(:bug) { create(:group_label, group: group, name: 'Bug') }
let(:development) { create(:group_label, group: group, name: 'Development') }
let(:testing) { create(:group_label, group: group, name: 'Testing') }
let(:regression) { create(:group_label, group: group, name: 'Regression') }
let!(:list1) { create(:list, board: board1, label: development, position: 0) }
let!(:list2) { create(:list, board: board1, label: testing, position: 1) }
let!(:closed) { create(:closed_list, board: board1) }
let(:parent) { group }
before do
parent.add_developer(user)
end
it_behaves_like 'issues move service', true
end
describe '#execute_multiple' do
let_it_be(:group) { create(:group) }
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project, namespace: group) }
let_it_be(:board1) { create(:board, group: group) }
let_it_be(:development) { create(:group_label, group: group, name: 'Development') }
let_it_be(:testing) { create(:group_label, group: group, name: 'Testing') }
let_it_be(:list1) { create(:list, board: board1, label: development, position: 0) }
let_it_be(:list2) { create(:list, board: board1, label: testing, position: 1) }
let(:params) { { board_id: board1.id, from_list_id: list1.id, to_list_id: list2.id } }
before do
project.add_developer(user)
end
it 'returns the expected result if list of issues is empty' do
expect(described_class.new(group, user, params).execute_multiple([])).to eq({ count: 0, success: false, issues: [] })
end
context 'moving multiple issues' do
let(:issue1) { create(:labeled_issue, project: project, labels: [development]) }
let(:issue2) { create(:labeled_issue, project: project, labels: [development]) }
it 'moves multiple issues from one list to another' do
expect(described_class.new(group, user, params).execute_multiple([issue1, issue2])).to be_truthy
expect(issue1.labels).to eq([testing])
expect(issue2.labels).to eq([testing])
end
end
context 'moving a single issue' do
let(:issue1) { create(:labeled_issue, project: project, labels: [development]) }
it 'moves one issue' do
expect(described_class.new(group, user, params).execute_multiple([issue1])).to be_truthy
expect(issue1.labels).to eq([testing])
end
end
context 'moving issues visually after an existing issue' do
let(:existing_issue) { create(:labeled_issue, project: project, labels: [testing], relative_position: 10) }
let(:issue1) { create(:labeled_issue, project: project, labels: [development]) }
let(:issue2) { create(:labeled_issue, project: project, labels: [development]) }
let(:move_params) do
params.dup.tap do |hash|
hash[:move_before_id] = existing_issue.id
end
end
it 'moves one issue' do
expect(described_class.new(group, user, move_params).execute_multiple([issue1, issue2])).to be_truthy
expect(issue1.labels).to eq([testing])
expect(issue2.labels).to eq([testing])
expect(issue1.relative_position > existing_issue.relative_position).to eq(true)
expect(issue2.relative_position > issue1.relative_position).to eq(true)
end
end
context 'moving issues visually before an existing issue' do
let(:existing_issue) { create(:labeled_issue, project: project, labels: [testing], relative_position: 10) }
let(:issue1) { create(:labeled_issue, project: project, labels: [development]) }
let(:issue2) { create(:labeled_issue, project: project, labels: [development]) }
let(:move_params) do
params.dup.tap do |hash|
hash[:move_after_id] = existing_issue.id
end
end
it 'moves one issue' do
expect(described_class.new(group, user, move_params).execute_multiple([issue1, issue2])).to be_truthy
expect(issue1.labels).to eq([testing])
expect(issue2.labels).to eq([testing])
expect(issue2.relative_position < existing_issue.relative_position).to eq(true)
expect(issue1.relative_position < issue2.relative_position).to eq(true)
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Boards
module Issues
class ListService < Boards::BaseItemsListService
include Gitlab::Utils::StrongMemoize
def self.valid_params
IssuesFinder.valid_params
end
# It is a class method because we cannot apply it
# prior to knowing how many items should be fetched for a list.
def self.initialize_relative_positions(board, current_user, issues)
if Gitlab::Database.read_write? && !board.disabled_for?(current_user)
Issue.move_nulls_to_end(issues)
end
end
private
def order(items)
return items.order_closed_at_desc if list&.closed?
items.order_by_relative_position
end
def finder
IssuesFinder.new(current_user, filter_params)
end
def board
@board ||= parent.boards.find(params[:board_id])
end
def filter_params
set_scope
set_non_archived
set_issue_types
super
end
def set_scope
params[:include_subgroups] = board.group_board?
end
def set_non_archived
params[:non_archived] = parent.is_a?(Group)
end
def set_issue_types
params[:issue_types] ||= Issue::TYPES_FOR_BOARD_LIST
end
def item_model
Issue
end
end
end
end
Boards::Issues::ListService.prepend_mod_with('Boards::Issues::ListService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Boards::Issues::ListService, feature_category: :team_planning do
describe '#execute' do
let_it_be(:user) { create(:user) }
context 'when parent is a project' do
let_it_be(:project) { create(:project, :empty_repo) }
let_it_be(:board) { create(:board, project: project) }
let_it_be(:m1) { create(:milestone, project: project) }
let_it_be(:m2) { create(:milestone, project: project) }
let_it_be(:bug) { create(:label, project: project, name: 'Bug') }
let_it_be(:development) { create(:label, project: project, name: 'Development') }
let_it_be(:testing) { create(:label, project: project, name: 'Testing') }
let_it_be(:p1) { create(:label, title: 'P1', project: project, priority: 1) }
let_it_be(:p2) { create(:label, title: 'P2', project: project, priority: 2) }
let_it_be(:p3) { create(:label, title: 'P3', project: project, priority: 3) }
let_it_be(:backlog) { board.lists.backlog.first }
let_it_be(:list1) { create(:list, board: board, label: development, position: 0) }
let_it_be(:list2) { create(:list, board: board, label: testing, position: 1) }
let_it_be(:closed) { board.lists.closed.first }
let_it_be(:opened_issue1) { create(:labeled_issue, project: project, milestone: m1, title: 'Issue 1', labels: [bug]) }
let_it_be(:opened_issue2) { create(:labeled_issue, project: project, milestone: m2, title: 'Issue 2', labels: [p2]) }
let_it_be(:reopened_issue1) { create(:issue, :opened, project: project, title: 'Reopened Issue 1') }
let_it_be(:list1_issue1) { create(:labeled_issue, project: project, milestone: m1, labels: [p2, development]) }
let_it_be(:list1_issue2) { create(:labeled_issue, project: project, milestone: m2, labels: [development]) }
let_it_be(:list1_issue3) { create(:labeled_issue, project: project, milestone: m1, labels: [development, p1]) }
let_it_be(:list2_issue1) { create(:labeled_issue, project: project, milestone: m1, labels: [testing]) }
let_it_be(:closed_issue1) { create(:labeled_issue, :closed, project: project, labels: [bug], closed_at: 1.day.ago) }
let_it_be(:closed_issue2) { create(:labeled_issue, :closed, project: project, labels: [p3], closed_at: 2.days.ago) }
let_it_be(:closed_issue3) { create(:issue, :closed, project: project, closed_at: 1.week.ago) }
let_it_be(:closed_issue4) { create(:labeled_issue, :closed, project: project, labels: [p1], closed_at: 1.year.ago) }
let_it_be(:closed_issue5) { create(:labeled_issue, :closed, project: project, labels: [development], closed_at: 2.years.ago) }
let(:parent) { project }
before do
project.add_developer(user)
end
it_behaves_like 'issues list service'
context 'when project is archived' do
before do
project.update!(archived: true)
end
it_behaves_like 'issues list service'
end
context 'when filtering' do
let_it_be(:incident) do
create(
:labeled_issue,
:incident,
project: project,
milestone: m1,
labels: [development, p1]
)
end
context 'when filtering by type' do
it 'only returns the specified type' do
params = { board_id: board.id, id: list1.id, issue_types: 'incident' }
expect(described_class.new(parent, user, params).execute).to eq [incident]
end
end
context 'when filtering by negated type' do
it 'only returns the specified type' do
params = { board_id: board.id, id: list1.id, not: { issue_types: ['issue'] } }
expect(described_class.new(parent, user, params).execute).to contain_exactly(incident)
end
end
end
end
context 'when parent is a group' do
let(:project) { create(:project, :empty_repo, namespace: group) }
let(:project1) { create(:project, :empty_repo, namespace: group) }
let(:project_archived) { create(:project, :empty_repo, :archived, namespace: group) }
let(:m1) { create(:milestone, group: group) }
let(:m2) { create(:milestone, group: group) }
let(:bug) { create(:group_label, group: group, name: 'Bug') }
let(:development) { create(:group_label, group: group, name: 'Development') }
let(:testing) { create(:group_label, group: group, name: 'Testing') }
let(:p1) { create(:group_label, title: 'P1', group: group) }
let(:p2) { create(:group_label, title: 'P2', group: group) }
let(:p3) { create(:group_label, title: 'P3', group: group) }
let(:p1_project) { create(:label, title: 'P1_project', project: project, priority: 1) }
let(:p2_project) { create(:label, title: 'P2_project', project: project, priority: 2) }
let(:p3_project) { create(:label, title: 'P3_project', project: project, priority: 3) }
let(:p1_project1) { create(:label, title: 'P1_project1', project: project1, priority: 1) }
let(:p2_project1) { create(:label, title: 'P2_project1', project: project1, priority: 2) }
let(:p3_project1) { create(:label, title: 'P3_project1', project: project1, priority: 3) }
let!(:backlog) { board.lists.backlog.first }
let!(:list1) { create(:list, board: board, label: development, position: 0) }
let!(:list2) { create(:list, board: board, label: testing, position: 1) }
let!(:closed) { board.lists.closed.first }
let!(:opened_issue1) { create(:labeled_issue, project: project, milestone: m1, title: 'Issue 1', labels: [bug]) }
let!(:opened_issue2) { create(:labeled_issue, project: project, milestone: m2, title: 'Issue 2', labels: [p2, p2_project]) }
let!(:opened_issue3) { create(:labeled_issue, project: project_archived, milestone: m1, title: 'Issue 3', labels: [bug]) }
let!(:reopened_issue1) { create(:issue, state: 'opened', project: project, title: 'Reopened Issue 1', closed_at: Time.current) }
let!(:list1_issue1) { create(:labeled_issue, project: project, milestone: m1, labels: [p2, p2_project, development]) }
let!(:list1_issue2) { create(:labeled_issue, project: project, milestone: m2, labels: [development]) }
let!(:list1_issue3) { create(:labeled_issue, project: project1, milestone: m1, labels: [development, p1, p1_project1]) }
let!(:list2_issue1) { create(:labeled_issue, project: project1, milestone: m1, labels: [testing]) }
let!(:closed_issue1) { create(:labeled_issue, :closed, project: project, labels: [bug], closed_at: 1.day.ago) }
let!(:closed_issue2) { create(:labeled_issue, :closed, project: project, labels: [p3, p3_project], closed_at: 2.days.ago) }
let!(:closed_issue3) { create(:issue, :closed, project: project1, closed_at: 1.week.ago) }
let!(:closed_issue4) { create(:labeled_issue, :closed, project: project1, labels: [p1, p1_project1], closed_at: 1.year.ago) }
let!(:closed_issue5) { create(:labeled_issue, :closed, project: project1, labels: [development], closed_at: 2.years.ago) }
before do
group.add_developer(user)
end
context 'when the group has no parent' do
let(:parent) { group }
let(:group) { create(:group) }
let(:board) { create(:board, group: group) }
it_behaves_like 'issues list service'
end
context 'when the group is an ancestor' do
let(:parent) { create(:group) }
let(:group) { create(:group, parent: parent) }
let(:board) { create(:board, group: parent) }
before do
parent.add_developer(user)
end
it_behaves_like 'issues list service'
end
end
end
describe '.initialize_relative_positions' do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project, :empty_repo) }
let_it_be(:board) { create(:board, project: project) }
let(:issue) { create(:issue, project: project, relative_position: nil) }
context "when 'Gitlab::Database::read_write?' is true" do
before do
allow(Gitlab::Database).to receive(:read_write?).and_return(true)
end
context 'user cannot move issues' do
it 'does not initialize the relative positions of issues' do
described_class.initialize_relative_positions(board, user, [issue])
expect(issue.relative_position).to eq nil
end
end
context 'user can move issues' do
before do
project.add_developer(user)
end
it 'initializes the relative positions of issues' do
described_class.initialize_relative_positions(board, user, [issue])
expect(issue.relative_position).not_to eq nil
end
end
end
context "when 'Gitlab::Database::read_write?' is false" do
before do
allow(Gitlab::Database).to receive(:read_write?).and_return(false)
end
it 'does not initialize the relative positions of issues' do
described_class.initialize_relative_positions(board, user, [issue])
expect(issue.relative_position).to eq nil
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Boards
module Issues
class CreateService < Boards::BaseService
attr_accessor :project
def initialize(parent, project, user, params = {})
@project = project
super(parent, user, params)
end
def execute
create_issue(params.merge(issue_params))
end
private
def issue_params
{ label_ids: [list.label_id] }
end
def board
@board ||= parent.boards.find(params.delete(:board_id))
end
def list
@list ||= board.lists.find(params.delete(:list_id))
end
def create_issue(params)
# NOTE: We are intentionally not doing a spam/CAPTCHA check for issues created via boards.
# See https://gitlab.com/gitlab-org/gitlab/-/issues/29400#note_598479184 for more context.
::Issues::CreateService.new(container: project, current_user: current_user, params: params, perform_spam_check: false).execute
end
end
end
end
Boards::Issues::CreateService.prepend_mod_with('Boards::Issues::CreateService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Boards::Issues::CreateService, feature_category: :team_planning do
describe '#execute' do
let(:project) { create(:project) }
let(:board) { create(:board, project: project) }
let(:user) { create(:user) }
let(:label) { create(:label, project: project, name: 'in-progress') }
let!(:list) { create(:list, board: board, label: label, position: 0) }
subject(:service) { described_class.new(board.resource_parent, project, user, board_id: board.id, list_id: list.id, title: 'New issue') }
before do
project.add_developer(user)
end
it 'delegates the create proceedings to Issues::CreateService' do
expect_next_instance_of(Issues::CreateService) do |instance|
expect(instance).to receive(:execute).once
end
service.execute
end
it 'creates a new issue' do
expect { service.execute }.to change(project.issues, :count).by(1)
end
it 'adds the label of the list to the issue' do
result = service.execute
expect(result).to be_success
expect(result[:issue].labels).to contain_exactly(label)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Submodules
class UpdateService < Commits::CreateService
include Gitlab::Utils::StrongMemoize
def initialize(*args)
super
@start_branch = @branch_name
@commit_sha = params[:commit_sha].presence
@submodule = params[:submodule].presence
@commit_message = params[:commit_message].presence || "Update submodule #{@submodule} with oid #{@commit_sha}"
end
def validate!
super
raise ValidationError, 'The repository is empty' if repository.empty?
end
def execute
super
rescue StandardError => e
error(e.message)
end
def create_commit!
repository.update_submodule(
current_user,
@submodule,
@commit_sha,
message: @commit_message,
branch: @branch_name
)
rescue ArgumentError, TypeError
raise ValidationError, 'Invalid parameters'
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Submodules::UpdateService, feature_category: :source_code_management do
let(:project) { create(:project, :repository) }
let(:repository) { project.repository }
let(:user) { create(:user, :commit_email) }
let(:branch_name) { project.default_branch }
let(:submodule) { 'six' }
let(:commit_sha) { 'e25eda1fece24ac7a03624ed1320f82396f35bd8' }
let(:commit_message) { 'whatever' }
let(:current_sha) { repository.blob_at('HEAD', submodule).id }
let(:commit_params) do
{
submodule: submodule,
commit_message: commit_message,
commit_sha: commit_sha,
branch_name: branch_name
}
end
subject { described_class.new(project, user, commit_params) }
describe "#execute" do
shared_examples 'returns error result' do
it do
result = subject.execute
expect(result[:status]).to eq :error
expect(result[:message]).to eq error_message
end
end
context 'when the user is not authorized' do
it_behaves_like 'returns error result' do
let(:error_message) { 'You are not allowed to push into this branch' }
end
end
context 'when the user is authorized' do
before do
project.add_maintainer(user)
end
context 'when the branch is protected' do
before do
create(:protected_branch, :no_one_can_push, project: project, name: branch_name)
end
it_behaves_like 'returns error result' do
let(:error_message) { 'You are not allowed to push into this branch' }
end
end
context 'validations' do
context 'when submodule' do
context 'is empty' do
let(:submodule) { '' }
it_behaves_like 'returns error result' do
let(:error_message) { 'Invalid parameters' }
end
end
context 'is not present' do
let(:submodule) { nil }
it_behaves_like 'returns error result' do
let(:error_message) { 'Invalid parameters' }
end
end
context 'is invalid' do
let(:submodule) { 'VERSION' }
it_behaves_like 'returns error result' do
let(:error_message) { 'Invalid submodule path' }
end
end
context 'does not exist' do
let(:submodule) { 'non-existent-submodule' }
it_behaves_like 'returns error result' do
let(:error_message) { 'Invalid submodule path' }
end
end
# Can be re-enabled when problem from https://gitlab.com/gitlab-org/gitlab/-/issues/413964#note_1421909142
# is fixed
# context 'has traversal path' do
# let(:submodule) { '../six' }
# it_behaves_like 'returns error result' do
# let(:error_message) { 'Invalid submodule path' }
# end
# end
end
context 'commit_sha' do
context 'is empty' do
let(:commit_sha) { '' }
it_behaves_like 'returns error result' do
let(:error_message) { 'Invalid parameters' }
end
end
context 'is not present' do
let(:commit_sha) { nil }
it_behaves_like 'returns error result' do
let(:error_message) { 'Invalid parameters' }
end
end
context 'is invalid' do
let(:commit_sha) { '1' }
it_behaves_like 'returns error result' do
let(:error_message) { 'Invalid parameters' }
end
end
context 'is the same as the current ref' do
let(:commit_sha) { current_sha }
it_behaves_like 'returns error result' do
let(:error_message) { "The submodule #{submodule} is already at #{commit_sha}" }
end
end
end
context 'branch_name' do
context 'is empty' do
let(:branch_name) { '' }
it_behaves_like 'returns error result' do
let(:error_message) { 'You can only create or edit files when you are on a branch' }
end
end
context 'is not present' do
let(:branch_name) { nil }
it_behaves_like 'returns error result' do
let(:error_message) { 'Invalid parameters' }
end
end
context 'does not exist' do
let(:branch_name) { 'non/existent-branch' }
it_behaves_like 'returns error result' do
let(:error_message) { 'You can only create or edit files when you are on a branch' }
end
end
context 'when commit message is empty' do
let(:commit_message) { '' }
it 'a default commit message is set' do
message = "Update submodule #{submodule} with oid #{commit_sha}"
expect(repository).to receive(:update_submodule).with(any_args, hash_including(message: message))
subject.execute
end
end
end
end
context 'when there is an unexpected error' do
before do
allow(repository).to receive(:update_submodule).and_raise(StandardError, 'error message')
end
it_behaves_like 'returns error result' do
let(:error_message) { 'error message' }
end
end
it 'updates the submodule reference' do
result = subject.execute
expect(result[:status]).to eq :success
expect(result[:result]).to eq repository.head_commit.id
expect(repository.blob_at('HEAD', submodule).id).to eq commit_sha
end
context 'when submodule is inside a directory' do
let(:submodule) { 'test_inside_folder/another_folder/six' }
let(:branch_name) { 'submodule_inside_folder' }
it 'updates the submodule reference' do
expect(repository.blob_at(branch_name, submodule).id).not_to eq commit_sha
subject.execute
expect(repository.blob_at(branch_name, submodule).id).to eq commit_sha
end
end
context 'when repository is empty' do
let(:project) { create(:project, :empty_repo) }
let(:branch_name) { 'master' }
it_behaves_like 'returns error result' do
let(:error_message) { 'The repository is empty' }
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
# This service copies AwardEmoji from one Awardable to another.
#
# It expects the calling code to have performed the necessary authorization
# checks in order to allow the copy to happen.
module AwardEmojis
class CopyService
def initialize(from_awardable, to_awardable)
raise ArgumentError, 'Awardables must be different' if from_awardable == to_awardable
@from_awardable = from_awardable
@to_awardable = to_awardable
end
def execute
from_awardable.award_emoji.find_each do |award|
new_award = award.dup
new_award.awardable = to_awardable
new_award.save!
end
ServiceResponse.success
end
private
attr_accessor :from_awardable, :to_awardable
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AwardEmojis::CopyService, feature_category: :team_planning do
let_it_be(:from_awardable) do
create(
:issue,
award_emoji: [
build(:award_emoji, name: 'thumbsup'),
build(:award_emoji, name: 'thumbsdown')
])
end
describe '#initialize' do
it 'validates that we cannot copy AwardEmoji to the same Awardable' do
expect { described_class.new(from_awardable, from_awardable) }.to raise_error(ArgumentError)
end
end
describe '#execute' do
let(:to_awardable) { create(:issue) }
subject(:execute_service) { described_class.new(from_awardable, to_awardable).execute }
it 'copies AwardEmojis', :aggregate_failures do
expect { execute_service }.to change { AwardEmoji.count }.by(2)
expect(to_awardable.award_emoji.map(&:name)).to match_array(%w[thumbsup thumbsdown])
end
it 'returns success', :aggregate_failures do
expect(execute_service).to be_kind_of(ServiceResponse)
expect(execute_service).to be_success
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
# Class for retrieving information about emoji awarded _by_ a particular user.
module AwardEmojis
class CollectUserEmojiService
attr_reader :current_user
# current_user - The User to generate the data for.
def initialize(current_user = nil)
@current_user = current_user
end
def execute
return [] unless current_user
# We want the resulting data set to be an Array containing the emoji names
# in descending order, based on how often they were awarded.
AwardEmoji
.award_counts_for_user(current_user)
.map { |name, _| { name: name } }
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AwardEmojis::CollectUserEmojiService, feature_category: :team_planning do
describe '#execute' do
it 'returns an Array containing the awarded emoji names' do
user = create(:user)
create(:award_emoji, user: user, name: 'thumbsup')
create(:award_emoji, user: user, name: 'thumbsup')
create(:award_emoji, user: user, name: 'thumbsdown')
awarded = described_class.new(user).execute
expect(awarded).to eq([{ name: 'thumbsup' }, { name: 'thumbsdown' }])
end
it 'returns an empty Array when no user is given' do
awarded = described_class.new.execute
expect(awarded).to be_empty
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module AwardEmojis
class AddService < AwardEmojis::BaseService
include Gitlab::Utils::StrongMemoize
def execute
unless awardable.user_can_award?(current_user)
return error('User cannot add emoji reactions to awardable', status: :forbidden)
end
unless awardable.emoji_awardable?
return error('Awardable cannot add emoji reactions', status: :unprocessable_entity)
end
award = awardable.award_emoji.create(name: name, user: current_user)
if award.persisted?
after_create(award)
success(award: award)
else
error(award.errors.full_messages, award: award)
end
end
private
def after_create(award)
TodoService.new.new_award_emoji(todoable, current_user) if todoable
execute_hooks(award, 'award')
end
def todoable
strong_memoize(:todoable) do
case awardable
when Note
# We don't create todos for personal snippet comments for now
awardable.noteable unless awardable.for_personal_snippet?
when MergeRequest, Issue
awardable
else
# No todos for all other awardables
nil
end
end
end
end
end
AwardEmojis::AddService.prepend_mod_with('AwardEmojis::AddService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AwardEmojis::AddService, feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project) }
let_it_be(:awardable) { create(:note, project: project) }
let(:name) { 'thumbsup' }
subject(:service) { described_class.new(awardable, name, user) }
describe '#execute' do
context 'when user is not authorized' do
it 'does not add an emoji' do
expect { service.execute }.not_to change { AwardEmoji.count }
end
it 'returns an error state' do
result = service.execute
expect(result[:status]).to eq(:error)
expect(result[:http_status]).to eq(:forbidden)
end
end
context 'when user is authorized' do
before do
project.add_developer(user)
end
it 'creates an award emoji' do
expect { service.execute }.to change { AwardEmoji.count }.by(1)
end
it 'returns the award emoji' do
result = service.execute
expect(result[:award]).to be_kind_of(AwardEmoji)
end
it 'return a success status' do
result = service.execute
expect(result[:status]).to eq(:success)
end
it 'sets the correct properties on the award emoji' do
award = service.execute[:award]
expect(award.name).to eq(name)
expect(award.user).to eq(user)
end
it 'executes hooks' do
expect(service).to receive(:execute_hooks).with(kind_of(AwardEmoji), 'award')
service.execute
end
describe 'marking Todos as done' do
subject { service.execute }
include_examples 'creating award emojis marks Todos as done'
end
context 'when the awardable cannot have emoji awarded to it' do
before do
expect(awardable).to receive(:emoji_awardable?).and_return(false)
end
it 'does not add an emoji' do
expect { service.execute }.not_to change { AwardEmoji.count }
end
it 'returns an error status' do
result = service.execute
expect(result[:status]).to eq(:error)
expect(result[:http_status]).to eq(:unprocessable_entity)
end
end
context 'when the awardable is invalid' do
before do
expect_next_instance_of(AwardEmoji) do |award|
expect(award).to receive(:valid?).and_return(false)
expect(award).to receive_message_chain(:errors, :full_messages).and_return(['Error 1', 'Error 2'])
end
end
it 'does not add an emoji' do
expect { service.execute }.not_to change { AwardEmoji.count }
end
it 'returns an error status' do
result = service.execute
expect(result[:status]).to eq(:error)
end
it 'returns an error message' do
result = service.execute
expect(result[:message]).to eq('Error 1 and Error 2')
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module AwardEmojis
class BaseService < ::BaseService
attr_accessor :awardable, :name
def initialize(awardable, name, current_user)
@awardable = awardable
@name = normalize_name(name)
super(awardable.project, current_user)
end
def execute_hooks(award_emoji, action)
return unless awardable.project&.has_active_hooks?(:emoji_hooks)
hook_data = Gitlab::DataBuilder::Emoji.build(award_emoji, current_user, action)
awardable.project.execute_hooks(hook_data, :emoji_hooks)
end
private
def normalize_name(name)
TanukiEmoji.find_by_alpha_code(name)&.name || name
end
# Provide more error state data than what BaseService allows.
# - An array of errors
# - The `AwardEmoji` if present
def error(errors, award: nil, status: nil)
errors = Array.wrap(errors)
super(errors.to_sentence.presence, status).merge({
award: award,
errors: errors
})
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AwardEmojis::BaseService, feature_category: :team_planning do
let_it_be(:group) { create(:group) }
let_it_be(:project) { create(:project, group: group) }
let_it_be(:current_user) { create(:user) }
let_it_be_with_reload(:awardable) { create(:note, project: project) }
let(:emoji_name) { 'horse' }
describe '.initialize' do
subject { described_class }
it 'uses same emoji name if not an alias' do
expect(subject.new(awardable, emoji_name, current_user).name).to eq(emoji_name)
end
it 'uses emoji original name if its an alias' do
emoji_alias = 'small_airplane'
emoji_name = 'airplane_small'
expect(subject.new(awardable, emoji_alias, current_user).name).to eq(emoji_name)
end
end
describe '.execute_hooks' do
let(:award_emoji) { create(:award_emoji, awardable: awardable) }
let(:action) { 'award' }
subject { described_class.new(awardable, emoji_name, current_user) }
context 'with no emoji hooks configured' do
it 'does not build hook_data' do
expect(Gitlab::DataBuilder::Emoji).not_to receive(:build)
expect(award_emoji.awardable.project).not_to receive(:execute_hooks)
subject.execute_hooks(award_emoji, action)
end
end
context 'with emoji hooks configured' do
it 'builds hook_data and calls execute_hooks for project' do
hook_data = {}
create(:project_hook, project: project, emoji_events: true)
expect(Gitlab::DataBuilder::Emoji).to receive(:build).and_return(hook_data)
expect(award_emoji.awardable.project).to receive(:execute_hooks).with(hook_data, :emoji_hooks)
subject.execute_hooks(award_emoji, action)
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module AwardEmojis
class DestroyService < AwardEmojis::BaseService
def execute
unless awardable.user_can_award?(current_user)
return error('User cannot destroy emoji on the awardable', status: :forbidden)
end
awards = AwardEmojisFinder.new(awardable, name: name, awarded_by: current_user).execute
if awards.empty?
return error("User has not awarded emoji of type #{name} on the awardable", status: :forbidden)
end
award = awards.destroy_all.first # rubocop: disable Cop/DestroyAll
after_destroy(award)
success(award: award)
end
private
def after_destroy(award)
execute_hooks(award, 'revoke')
end
end
end
AwardEmojis::DestroyService.prepend_mod_with('AwardEmojis::DestroyService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AwardEmojis::DestroyService, feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let_it_be(:awardable) { create(:note) }
let_it_be(:project) { awardable.project }
let(:name) { 'thumbsup' }
let!(:award_from_other_user) do
create(:award_emoji, name: name, awardable: awardable, user: create(:user))
end
subject(:service) { described_class.new(awardable, name, user) }
describe '#execute' do
shared_examples_for 'a service that does not authorize the user' do |error:|
it 'does not remove the emoji' do
expect { service.execute }.not_to change { AwardEmoji.count }
end
it 'returns an error state' do
result = service.execute
expect(result[:status]).to eq(:error)
expect(result[:http_status]).to eq(:forbidden)
end
it 'returns a nil award' do
result = service.execute
expect(result).to have_key(:award)
expect(result[:award]).to be_nil
end
it 'returns the error' do
result = service.execute
expect(result[:message]).to eq(error)
expect(result[:errors]).to eq([error])
end
end
context 'when user is not authorized' do
it_behaves_like 'a service that does not authorize the user',
error: 'User cannot destroy emoji on the awardable'
end
context 'when the user is authorized' do
before do
project.add_developer(user)
end
context 'when user has not awarded an emoji to the awardable' do
let!(:award_from_user) { create(:award_emoji, name: name, user: user) }
it_behaves_like 'a service that does not authorize the user',
error: 'User has not awarded emoji of type thumbsup on the awardable'
end
context 'when user has awarded an emoji to the awardable' do
let!(:award_from_user) { create(:award_emoji, name: name, awardable: awardable, user: user) }
it 'removes the emoji' do
expect { service.execute }.to change { AwardEmoji.count }.by(-1)
end
it 'returns a success status' do
result = service.execute
expect(result[:status]).to eq(:success)
end
it 'returns no errors' do
result = service.execute
expect(result).not_to have_key(:error)
expect(result).not_to have_key(:errors)
end
it 'returns the destroyed award' do
result = service.execute
expect(result[:award]).to eq(award_from_user)
expect(result[:award]).to be_destroyed
end
it 'executes hooks' do
expect(service).to receive(:execute_hooks).with(award_from_user, 'revoke')
service.execute
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module AwardEmojis
class ToggleService < AwardEmojis::BaseService
def execute
if awardable.awarded_emoji?(name, current_user)
DestroyService.new(awardable, name, current_user).execute
else
AddService.new(awardable, name, current_user).execute
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe AwardEmojis::ToggleService, feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project, :public) }
let_it_be(:awardable) { create(:note, project: project) }
let(:name) { 'thumbsup' }
subject(:service) { described_class.new(awardable, name, user) }
describe '#execute' do
context 'when user has awarded an emoji' do
let!(:award_from_other_user) { create(:award_emoji, name: name, awardable: awardable, user: create(:user)) }
let!(:award) { create(:award_emoji, name: name, awardable: awardable, user: user) }
it 'calls AwardEmojis::DestroyService' do
expect(AwardEmojis::AddService).not_to receive(:new)
expect_next_instance_of(AwardEmojis::DestroyService) do |service|
expect(service).to receive(:execute)
end
service.execute
end
it 'destroys an AwardEmoji' do
expect { service.execute }.to change { AwardEmoji.count }.by(-1)
end
it 'returns the result of DestroyService#execute' do
mock_result = double(foo: true)
expect_next_instance_of(AwardEmojis::DestroyService) do |service|
expect(service).to receive(:execute).and_return(mock_result)
end
result = service.execute
expect(result).to eq(mock_result)
end
end
context 'when user has not awarded an emoji' do
it 'calls AwardEmojis::AddService' do
expect_next_instance_of(AwardEmojis::AddService) do |service|
expect(service).to receive(:execute)
end
expect(AwardEmojis::DestroyService).not_to receive(:new)
service.execute
end
it 'creates an AwardEmoji' do
expect { service.execute }.to change { AwardEmoji.count }.by(1)
end
it 'returns the result of AddService#execute' do
mock_result = double(foo: true)
expect_next_instance_of(AwardEmojis::AddService) do |service|
expect(service).to receive(:execute).and_return(mock_result)
end
result = service.execute
expect(result).to eq(mock_result)
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module VsCode
module Settings
class CreateOrUpdateService
def initialize(current_user:, params: {})
@current_user = current_user
@params = params
end
def execute
# The GitLab VSCode settings API does not support creating or updating
# machines.
return ServiceResponse.success(payload: DEFAULT_MACHINE) if @params[:setting_type] == 'machines'
setting = VsCodeSetting.by_user(current_user).by_setting_type(params[:setting_type]).first
if setting.nil?
merged_params = params.merge(user: current_user, uuid: SecureRandom.uuid)
setting = VsCodeSetting.new(merged_params)
else
setting.content = params[:content]
setting.uuid = SecureRandom.uuid
end
if setting.save
ServiceResponse.success(payload: setting)
else
ServiceResponse.error(
message: setting.errors.full_messages.to_sentence,
payload: { setting: setting }
)
end
end
private
attr_reader :current_user, :params
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe VsCode::Settings::CreateOrUpdateService, feature_category: :web_ide do
describe '#execute' do
let_it_be(:user) { create(:user) }
let(:opts) do
{
setting_type: "settings",
content: '{ "editor.fontSize": 12 }'
}
end
subject { described_class.new(current_user: user, params: opts).execute }
context 'when setting_type is machines' do
it 'returns default machine as a successful response' do
opts = { setting_type: "machines", machines: '[]' }
result = described_class.new(current_user: user, params: opts).execute
expect(result.payload).to eq(VsCode::Settings::DEFAULT_MACHINE)
end
end
it 'creates a new record when a record with the setting does not exist' do
expect { subject }.to change { User.find(user.id).vscode_settings.count }.from(0).to(1)
record = User.find(user.id).vscode_settings.by_setting_type('settings').first
expect(record.content).to eq('{ "editor.fontSize": 12 }')
end
it 'updates the existing record if setting exists' do
setting = create(:vscode_setting, user: user)
expect { subject }.to change {
VsCode::Settings::VsCodeSetting.find(setting.id).content
}.from(setting.content).to(opts[:content])
end
it 'fails if an invalid value is passed' do
invalid_opts = { setting_type: nil, content: nil }
result = described_class.new(current_user: user, params: invalid_opts).execute
expect(result.status).to eq(:error)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module VsCode
module Settings
class DeleteService
def initialize(current_user:)
@current_user = current_user
end
def execute
VsCodeSetting.by_user(current_user).delete_all
ServiceResponse.success
end
private
attr_reader :current_user
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe VsCode::Settings::DeleteService, feature_category: :web_ide do
describe '#execute' do
let_it_be(:user) { create(:user) }
let_it_be(:other_user) { create(:user) }
let_it_be(:setting_one) { create(:vscode_setting, user: user) }
let_it_be(:setting_two) { create(:vscode_setting, setting_type: 'extensions', user: user) }
let_it_be(:setting_three) { create(:vscode_setting, setting_type: 'extensions', user: other_user) }
subject { described_class.new(current_user: user).execute }
it 'deletes all vscode_settings belonging to the current user' do
expect { subject }
.to change { User.find(user.id).vscode_settings.count }.from(2).to(0)
.and not_change { User.find(other_user.id).vscode_settings.count }
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Milestones
class FindOrCreateService
attr_accessor :project, :current_user, :params
def initialize(project, user, params = {})
@project = project
@current_user = user
@params = params.dup
end
def execute
find_milestone || create_milestone
end
private
# rubocop: disable CodeReuse/ActiveRecord
def find_milestone
groups = project.group&.self_and_ancestors_ids
Milestone.for_projects_and_groups([project.id], groups).find_by(title: params["title"])
end
# rubocop: enable CodeReuse/ActiveRecord
def create_milestone
return unless current_user.can?(:admin_milestone, project)
new_milestone if new_milestone.persisted?
end
def new_milestone
@new_milestone ||= CreateService.new(project, current_user, params).execute
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Milestones::FindOrCreateService, feature_category: :team_planning do
describe '#execute' do
subject(:service) { described_class.new(project, user, params) }
let(:user) { create(:user) }
let(:group) { create(:group) }
let(:project) { create(:project, namespace: group) }
let(:params) do
{
title: '1.0',
description: 'First Release',
start_date: Date.today,
due_date: Date.today + 1.month
}.with_indifferent_access
end
context 'when finding milestone on project level' do
let!(:existing_project_milestone) { create(:milestone, project: project, title: '1.0') }
it 'returns existing milestone' do
expect(service.execute).to eq(existing_project_milestone)
end
end
context 'when finding milestone on group level' do
let!(:existing_group_milestone) { create(:milestone, group: group, title: '1.0') }
it 'returns existing milestone' do
expect(service.execute).to eq(existing_group_milestone)
end
end
context 'when not finding milestone' do
context 'when user has permissions' do
before do
project.add_developer(user)
end
context 'when params are valid' do
it 'creates a new milestone at project level using params' do
expect { service.execute }.to change(project.milestones, :count).by(1)
milestone = project.reload.milestones.last
expect(milestone.title).to eq(params[:title])
expect(milestone.description).to eq(params[:description])
expect(milestone.start_date).to eq(params[:start_date])
expect(milestone.due_date).to eq(params[:due_date])
end
end
context 'when params are not valid' do
before do
params[:start_date] = Date.today + 2.months
end
it 'returns nil' do
expect(service.execute).to be_nil
end
end
end
context 'when user does not have permissions' do
before do
project.add_guest(user)
end
it 'does not create a new milestone' do
expect { service.execute }.not_to change(project.milestones, :count)
end
it 'returns nil' do
expect(service.execute).to be_nil
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Milestones
class MergeRequestsCountService < BaseCountService
def initialize(milestone)
@milestone = milestone
end
def cache_key
"milestone_merge_requests_count_#{@milestone.milestoneish_id}"
end
def relation_for_count
@milestone.merge_requests
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Milestones::MergeRequestsCountService, :use_clean_rails_memory_store_caching,
feature_category: :team_planning do
let_it_be(:project) { create(:project, :empty_repo) }
let_it_be(:milestone) { create(:milestone, project: project) }
before_all do
create(:merge_request, milestone: milestone, source_project: project)
create(:merge_request, :closed, milestone: milestone, source_project: project)
end
subject { described_class.new(milestone) }
it_behaves_like 'a counter caching service'
it 'counts all merge requests' do
expect(subject.count).to eq(2)
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Milestones
class ClosedIssuesCountService < BaseCountService
def initialize(milestone)
@milestone = milestone
end
def cache_key
"milestone_closed_issues_count_#{@milestone.milestoneish_id}"
end
def relation_for_count
@milestone.issues.closed
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Milestones::ClosedIssuesCountService, :use_clean_rails_memory_store_caching,
feature_category: :team_planning do
let(:project) { create(:project) }
let(:milestone) { create(:milestone, project: project) }
before do
create(:issue, milestone: milestone, project: project)
create(:issue, :confidential, milestone: milestone, project: project)
create(:issue, :closed, milestone: milestone, project: project)
create(:issue, :closed, :confidential, milestone: milestone, project: project)
end
subject { described_class.new(milestone) }
it_behaves_like 'a counter caching service'
it 'counts closed issues including confidential' do
expect(subject.count).to eq(2)
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Milestones
class PromoteService < Milestones::BaseService
PromoteMilestoneError = Class.new(StandardError)
def execute(milestone)
check_project_milestone!(milestone)
Milestone.transaction do
group_milestone = clone_project_milestone(milestone)
move_children_to_group_milestone(group_milestone)
# Destroy all milestones with same title across projects
destroy_old_milestones(milestone)
# Rollback if milestone is not valid
unless group_milestone.valid?
raise_error(group_milestone.errors.full_messages.to_sentence)
end
group_milestone
end
end
private
def milestone_ids_for_merge(group_milestone)
# Pluck need to be used here instead of select so the array of ids
# is persistent after old milestones gets deleted.
@milestone_ids_for_merge ||= begin
search_params = { title: group_milestone.title, project_ids: group_project_ids, state: 'all' }
milestones = MilestonesFinder.new(search_params).execute
milestones.pluck_primary_key
end
end
def move_children_to_group_milestone(group_milestone)
milestone_ids_for_merge(group_milestone).in_groups_of(100, false) do |milestone_ids|
update_children(group_milestone, milestone_ids)
end
end
def check_project_milestone!(milestone)
raise_error(s_('PromoteMilestone|Only project milestones can be promoted.')) unless milestone.project_milestone?
end
def clone_project_milestone(milestone)
params = milestone.slice(:title, :description, :start_date, :due_date, :state_event)
create_service = CreateService.new(group, current_user, params)
milestone = create_service.execute
# milestone won't be valid here because of duplicated title
milestone.save(validate: false)
milestone
end
# rubocop: disable CodeReuse/ActiveRecord
def update_children(group_milestone, milestone_ids)
issues = Issue.where(project_id: group_project_ids, milestone_id: milestone_ids)
merge_requests = MergeRequest.where(source_project_id: group_project_ids, milestone_id: milestone_ids)
[issues, merge_requests].each do |issuable_collection|
issuable_collection.update_all(milestone_id: group_milestone.id)
end
end
# rubocop: enable CodeReuse/ActiveRecord
def group
@group ||= parent.group || raise_error(s_('PromoteMilestone|Project does not belong to a group.'))
end
# rubocop: disable CodeReuse/ActiveRecord
def destroy_old_milestones(milestone)
Milestone.where(id: milestone_ids_for_merge(milestone)).destroy_all # rubocop: disable Cop/DestroyAll
end
# rubocop: enable CodeReuse/ActiveRecord
def group_project_ids
group.projects.select(:id)
end
def raise_error(message)
raise PromoteMilestoneError, s_("PromoteMilestone|Promotion failed - %{message}") % { message: message }
end
end
end
Milestones::PromoteService.prepend_mod_with('Milestones::PromoteService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Milestones::PromoteService, feature_category: :team_planning do
let(:group) { create(:group) }
let(:project) { create(:project, namespace: group) }
let(:user) { create(:user) }
let(:milestone_title) { 'project milestone' }
let(:milestone) { create(:milestone, project: project, title: milestone_title) }
let(:service) { described_class.new(project, user) }
describe '#execute' do
before do
group.add_maintainer(user)
end
context 'validations' do
it 'raises error if milestone does not belong to a project' do
allow(milestone).to receive(:project_milestone?).and_return(false)
expect { service.execute(milestone) }.to raise_error(described_class::PromoteMilestoneError)
end
it 'raises error if project does not belong to a group' do
project.update!(namespace: user.namespace)
expect { service.execute(milestone) }.to raise_error(described_class::PromoteMilestoneError)
end
it 'does not promote milestone and update issuables if promoted milestone is not valid' do
issue = create(:issue, milestone: milestone, project: project)
merge_request = create(:merge_request, milestone: milestone, source_project: project)
allow_next_instance_of(Milestone) do |instance|
allow(instance).to receive(:valid?).and_return(false)
end
expect { service.execute(milestone) }.to raise_error(described_class::PromoteMilestoneError)
expect(milestone.reload).to be_persisted
expect(issue.reload.milestone).to eq(milestone)
expect(merge_request.reload.milestone).to eq(milestone)
end
end
context 'without duplicated milestone titles across projects' do
it 'promotes project milestone to group milestone' do
promoted_milestone = service.execute(milestone)
expect(promoted_milestone).to be_group_milestone
end
it 'does not update issuables without milestone with the new promoted milestone' do
issue_without_milestone = create(:issue, project: project, milestone: nil)
merge_request_without_milestone = create(:merge_request, milestone: nil, source_project: project)
service.execute(milestone)
expect(issue_without_milestone.reload.milestone).to be_nil
expect(merge_request_without_milestone.reload.milestone).to be_nil
end
it 'sets issuables with new promoted milestone' do
issue = create(:issue, milestone: milestone, project: project)
merge_request = create(:merge_request, milestone: milestone, source_project: project)
promoted_milestone = service.execute(milestone)
expect(promoted_milestone).to be_group_milestone
expect(issue.reload.milestone).to eq(promoted_milestone)
expect(merge_request.reload.milestone).to eq(promoted_milestone)
end
end
context 'with duplicated milestone titles across projects' do
let(:project_2) { create(:project, namespace: group) }
let!(:milestone_2) { create(:milestone, project: project_2, title: milestone_title) }
it 'deletes project milestones with the same title' do
promoted_milestone = service.execute(milestone)
expect(promoted_milestone).to be_group_milestone
expect(promoted_milestone).to be_valid
expect(Milestone.exists?(milestone.id)).to be_falsy
expect(Milestone.exists?(milestone_2.id)).to be_falsy
end
it 'does not update issuables without milestone with the new promoted milestone' do
issue_without_milestone_1 = create(:issue, project: project, milestone: nil)
issue_without_milestone_2 = create(:issue, project: project_2, milestone: nil)
merge_request_without_milestone_1 = create(:merge_request, milestone: nil, source_project: project)
merge_request_without_milestone_2 = create(:merge_request, milestone: nil, source_project: project_2)
service.execute(milestone)
expect(issue_without_milestone_1.reload.milestone).to be_nil
expect(issue_without_milestone_2.reload.milestone).to be_nil
expect(merge_request_without_milestone_1.reload.milestone).to be_nil
expect(merge_request_without_milestone_2.reload.milestone).to be_nil
end
it 'sets all issuables with new promoted milestone' do
issue = create(:issue, milestone: milestone, project: project)
issue_2 = create(:issue, milestone: milestone_2, project: project_2)
merge_request = create(:merge_request, milestone: milestone, source_project: project)
merge_request_2 = create(:merge_request, milestone: milestone_2, source_project: project_2)
promoted_milestone = service.execute(milestone)
expect(issue.reload.milestone).to eq(promoted_milestone)
expect(issue_2.reload.milestone).to eq(promoted_milestone)
expect(merge_request.reload.milestone).to eq(promoted_milestone)
expect(merge_request_2.reload.milestone).to eq(promoted_milestone)
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Milestones
class IssuesCountService < BaseCountService
def initialize(milestone)
@milestone = milestone
end
def cache_key
"milestone_total_issues_count_#{@milestone.milestoneish_id}"
end
def relation_for_count
@milestone.issues
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Milestones::IssuesCountService, :use_clean_rails_memory_store_caching,
feature_category: :team_planning do
let(:project) { create(:project) }
let(:milestone) { create(:milestone, project: project) }
before do
create(:issue, milestone: milestone, project: project)
create(:issue, :confidential, milestone: milestone, project: project)
create(:issue, :closed, milestone: milestone, project: project)
create(:issue, :closed, milestone: milestone, project: project)
end
subject { described_class.new(milestone) }
it_behaves_like 'a counter caching service'
it 'counts all issues including confidential' do
expect(subject.count).to eq(4)
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
# Milestones::TransferService class
#
# Used for recreating the missing group milestones at project level when
# transferring a project to a new namespace
#
module Milestones
class TransferService
attr_reader :current_user, :old_group, :project
def initialize(current_user, old_group, project)
@current_user = current_user
@old_group = old_group
@project = project
end
def execute
return unless old_group.present?
Milestone.transaction do
milestones_to_transfer.find_each do |milestone|
new_milestone = find_or_create_milestone(milestone)
update_issues_milestone(milestone, new_milestone)
update_merge_requests_milestone(milestone.id, new_milestone&.id)
delete_milestone_counts_caches(milestone)
delete_milestone_counts_caches(new_milestone)
end
end
end
private
# rubocop: disable CodeReuse/ActiveRecord
def milestones_to_transfer
Milestone.from_union([group_milestones_applied_to_issues, group_milestones_applied_to_merge_requests])
.reorder(nil)
.distinct
end
# rubocop: enable CodeReuse/ActiveRecord
# rubocop: disable CodeReuse/ActiveRecord
def group_milestones_applied_to_issues
Milestone.joins(:issues)
.where(
issues: { project_id: project.id },
group_id: old_group.self_and_ancestors
)
end
# rubocop: enable CodeReuse/ActiveRecord
# rubocop: disable CodeReuse/ActiveRecord
def group_milestones_applied_to_merge_requests
Milestone.joins(:merge_requests)
.where(
merge_requests: { target_project_id: project.id },
group_id: old_group.self_and_ancestors
)
end
# rubocop: enable CodeReuse/ActiveRecord
def find_or_create_milestone(milestone)
params = milestone.attributes.slice('title', 'description', 'start_date', 'due_date', 'state')
FindOrCreateService.new(project, current_user, params).execute
end
# rubocop: disable CodeReuse/ActiveRecord
def update_issues_milestone(old_milestone, new_milestone)
Issue.where(project: project, milestone_id: old_milestone.id)
.update_all(milestone_id: new_milestone&.id)
end
# rubocop: enable CodeReuse/ActiveRecord
# rubocop: disable CodeReuse/ActiveRecord
def update_merge_requests_milestone(old_milestone_id, new_milestone_id)
MergeRequest.where(project: project, milestone_id: old_milestone_id)
.update_all(milestone_id: new_milestone_id)
end
# rubocop: enable CodeReuse/ActiveRecord
def delete_milestone_counts_caches(milestone)
return unless milestone
Milestones::IssuesCountService.new(milestone).delete_cache
Milestones::ClosedIssuesCountService.new(milestone).delete_cache
Milestones::MergeRequestsCountService.new(milestone).delete_cache
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Milestones::TransferService, feature_category: :team_planning do
describe '#execute' do
subject(:service) { described_class.new(user, old_group, project) }
context 'when old_group is present' do
let(:user) { create(:admin) }
let(:new_group) { create(:group) }
let(:old_group) { create(:group) }
let(:project) { create(:project, namespace: old_group) }
let(:group_milestone) { create(:milestone, :closed, group: old_group) }
let(:group_milestone2) { create(:milestone, group: old_group) }
let(:project_milestone) { create(:milestone, project: project) }
let!(:issue_with_group_milestone) { create(:issue, project: project, milestone: group_milestone) }
let!(:issue_with_project_milestone) { create(:issue, project: project, milestone: project_milestone) }
let!(:mr_with_group_milestone) { create(:merge_request, source_project: project, source_branch: 'branch-1', milestone: group_milestone) }
let!(:mr_with_project_milestone) { create(:merge_request, source_project: project, source_branch: 'branch-2', milestone: project_milestone) }
before do
new_group.add_maintainer(user)
project.add_maintainer(user)
# simulate project transfer
project.update!(group: new_group)
end
context 'without existing milestone at the new group level' do
it 'recreates the missing group milestones at project level' do
expect { service.execute }.to change(project.milestones, :count).by(1)
end
it 'applies new project milestone to issues with group milestone' do
service.execute
new_milestone = issue_with_group_milestone.reload.milestone
expect(new_milestone).not_to eq(group_milestone)
expect(new_milestone.title).to eq(group_milestone.title)
expect(new_milestone.project_milestone?).to be_truthy
expect(new_milestone.state).to eq("closed")
end
context 'when milestone is from an ancestor group' do
let(:old_group_ancestor) { create(:group) }
let(:old_group) { create(:group, parent: old_group_ancestor) }
let(:group_milestone) { create(:milestone, group: old_group_ancestor) }
it 'recreates the missing group milestones at project level' do
expect { service.execute }.to change(project.milestones, :count).by(1)
end
end
it 'deletes milestone counters cache for both milestones' do
new_milestone = create(:milestone, project: project, title: group_milestone.title)
expect_next_instance_of(Milestones::IssuesCountService, group_milestone) do |service|
expect(service).to receive(:delete_cache).and_call_original
end
expect_next_instance_of(Milestones::ClosedIssuesCountService, group_milestone) do |service|
expect(service).to receive(:delete_cache).and_call_original
end
expect_next_instance_of(Milestones::MergeRequestsCountService, group_milestone) do |service|
expect(service).to receive(:delete_cache).and_call_original
end
expect_next_instance_of(Milestones::IssuesCountService, new_milestone) do |service|
expect(service).to receive(:delete_cache).and_call_original
end
expect_next_instance_of(Milestones::ClosedIssuesCountService, new_milestone) do |service|
expect(service).to receive(:delete_cache).and_call_original
end
expect_next_instance_of(Milestones::MergeRequestsCountService, new_milestone) do |service|
expect(service).to receive(:delete_cache).and_call_original
end
service.execute
end
it 'does not apply new project milestone to issues with project milestone' do
service.execute
expect(issue_with_project_milestone.reload.milestone).to eq(project_milestone)
end
it 'applies new project milestone to merge_requests with group milestone' do
service.execute
new_milestone = mr_with_group_milestone.reload.milestone
expect(new_milestone).not_to eq(group_milestone)
expect(new_milestone.title).to eq(group_milestone.title)
expect(new_milestone.project_milestone?).to be_truthy
expect(new_milestone.state).to eq("closed")
end
it 'does not apply new project milestone to issuables with project milestone' do
service.execute
expect(mr_with_project_milestone.reload.milestone).to eq(project_milestone)
end
it 'does not recreate missing group milestones that are not applied to issues or merge requests' do
service.execute
new_milestone_title = project.reload.milestones.pluck(:title)
expect(new_milestone_title).to include(group_milestone.title)
expect(new_milestone_title).not_to include(group_milestone2.title)
end
context 'when find_or_create_milestone returns nil' do
before do
allow_next_instance_of(Milestones::FindOrCreateService) do |instance|
allow(instance).to receive(:execute).and_return(nil)
end
end
it 'removes issues group milestone' do
service.execute
expect(mr_with_group_milestone.reload.milestone).to be_nil
end
it 'removes merge requests group milestone' do
service.execute
expect(issue_with_group_milestone.reload.milestone).to be_nil
end
end
end
context 'with existing milestone at the new group level' do
let!(:existing_milestone) { create(:milestone, group: new_group, title: group_milestone.title) }
it 'does not create a new milestone' do
expect { service.execute }.not_to change(project.milestones, :count)
end
it 'applies existing milestone to issues with group milestone' do
service.execute
expect(issue_with_group_milestone.reload.milestone).to eq(existing_milestone)
end
it 'applies existing milestone to merge_requests with group milestone' do
service.execute
expect(mr_with_group_milestone.reload.milestone).to eq(existing_milestone)
end
end
end
end
context 'when old_group is not present' do
let(:user) { create(:admin) }
let(:old_group) { project.group }
let(:project) { create(:project, namespace: user.namespace) }
it 'returns nil' do
expect(described_class.new(user, old_group, project).execute).to be_nil
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Milestones
class CloseService < Milestones::BaseService
def execute(milestone)
if milestone.close && milestone.project_milestone?
event_service.close_milestone(milestone, current_user)
end
milestone
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Milestones::CloseService, feature_category: :team_planning do
let(:user) { create(:user) }
let(:project) { create(:project) }
let(:milestone) { create(:milestone, title: "Milestone v1.2", project: project) }
before do
project.add_maintainer(user)
end
describe '#execute' do
before do
described_class.new(project, user, {}).execute(milestone)
end
it { expect(milestone).to be_valid }
it { expect(milestone).to be_closed }
describe 'event' do
let(:event) { Event.recent.first }
it { expect(event.milestone).to be_truthy }
it { expect(event.target).to eq(milestone) }
it { expect(event.action_name).to eq('closed') }
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Milestones
class DestroyService < Milestones::BaseService
def execute(milestone)
Milestone.transaction do
update_params = { milestone_id: nil, skip_milestone_email: true }
milestone.issues.each do |issue|
Issues::UpdateService.new(container: parent, current_user: current_user, params: update_params).execute(issue)
end
milestone.merge_requests.each do |merge_request|
MergeRequests::UpdateService.new(project: parent, current_user: current_user, params: update_params).execute(merge_request)
end
log_destroy_event_for(milestone)
milestone.destroy
end
end
def log_destroy_event_for(milestone)
return if milestone.group_milestone?
event_service.destroy_milestone(milestone, current_user)
Event.for_milestone_id(milestone.id).each do |event|
event.target_id = nil
event.save
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Milestones::DestroyService, feature_category: :team_planning do
let(:user) { create(:user) }
let(:project) { create(:project, :repository) }
let(:milestone) { create(:milestone, title: 'Milestone v1.0', project: project) }
before do
project.add_maintainer(user)
end
def service
described_class.new(project, user, {})
end
describe '#execute' do
it 'deletes milestone' do
service.execute(milestone)
expect { milestone.reload }.to raise_error ActiveRecord::RecordNotFound
end
context 'with an existing merge request' do
let!(:issue) { create(:issue, project: project, milestone: milestone) }
let!(:merge_request) { create(:merge_request, source_project: project, milestone: milestone) }
it 'deletes milestone id from issuables' do
service.execute(milestone)
expect(issue.reload.milestone).to be_nil
expect(merge_request.reload.milestone).to be_nil
end
end
it 'logs destroy event' do
service.execute(milestone)
event = Event.where(project_id: milestone.project_id, target_type: 'Milestone')
expect(event.count).to eq(1)
end
context 'group milestones' do
let(:group) { create(:group) }
let(:group_milestone) { create(:milestone, group: group) }
before do
project.update!(namespace: group)
group.add_developer(user)
end
it { expect(service.execute(group_milestone)).to eq(group_milestone) }
it 'deletes milestone id from issuables' do
issue = create(:issue, project: project, milestone: group_milestone)
merge_request = create(:merge_request, source_project: project, milestone: group_milestone)
service.execute(group_milestone)
expect(issue.reload.milestone).to be_nil
expect(merge_request.reload.milestone).to be_nil
end
it 'does not log destroy event' do
expect { service.execute(group_milestone) }.not_to change { Event.count }
end
end
context 'when a release is tied to a milestone' do
it 'destroys the milestone but not the associated release' do
release = create(
:release,
tag: 'v1.0',
project: project,
milestones: [milestone]
)
expect { service.execute(milestone) }.not_to change { Release.count }
expect(release.reload).to be_persisted
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Milestones
class UpdateService < Milestones::BaseService
def execute(milestone)
state = params[:state_event]
case state
when 'activate'
Milestones::ReopenService.new(parent, current_user, {}).execute(milestone)
when 'close'
Milestones::CloseService.new(parent, current_user, {}).execute(milestone)
end
if params.present?
milestone.assign_attributes(params.except(:state_event))
end
if milestone.changed?
before_update(milestone)
end
milestone.save
milestone
end
private
def before_update(milestone)
milestone.check_for_spam(user: current_user, action: :update)
end
end
end
Milestones::UpdateService.prepend_mod_with('Milestones::UpdateService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Milestones::UpdateService, feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project) }
let_it_be(:milestone) { create(:milestone, project: project) }
let_it_be(:params) { { title: 'New Title' } }
subject(:update_milestone) { described_class.new(project, user, params) }
describe '#execute' do
context 'when state_event is "activate"' do
let(:params) { { state_event: 'activate' } }
it 'calls Milestones::ReopenService' do
reopen_service = instance_double(Milestones::ReopenService)
expect(Milestones::ReopenService).to receive(:new).with(project, user, {}).and_return(reopen_service)
expect(reopen_service).to receive(:execute).with(milestone)
update_milestone.execute(milestone)
end
end
context 'when state_event is "close"' do
let(:params) { { state_event: 'close' } }
it 'calls Milestones::CloseService' do
close_service = instance_double(Milestones::CloseService)
expect(Milestones::CloseService).to receive(:new).with(project, user, {}).and_return(close_service)
expect(close_service).to receive(:execute).with(milestone)
update_milestone.execute(milestone)
end
end
context 'when params are present' do
it 'assigns the params to the milestone' do
expect(milestone).to receive(:assign_attributes).with(params.except(:state_event))
update_milestone.execute(milestone)
end
end
context 'when milestone is changed' do
before do
allow(milestone).to receive(:changed?).and_return(true)
end
it 'calls before_update' do
expect(update_milestone).to receive(:before_update).with(milestone)
update_milestone.execute(milestone)
end
end
context 'when milestone is not changed' do
before do
allow(milestone).to receive(:changed?).and_return(false)
end
it 'does not call before_update' do
expect(update_milestone).not_to receive(:before_update)
update_milestone.execute(milestone)
end
end
it 'saves the milestone' do
expect(milestone).to receive(:save)
update_milestone.execute(milestone)
end
it 'returns the milestone' do
expect(update_milestone.execute(milestone)).to eq(milestone)
end
end
describe '#before_update' do
it 'checks for spam' do
expect(milestone).to receive(:check_for_spam).with(user: user, action: :update)
update_milestone.send(:before_update, milestone)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Milestones
class CreateService < Milestones::BaseService
def execute
milestone = parent.milestones.new(params)
before_create(milestone)
if milestone.save && milestone.project_milestone?
event_service.open_milestone(milestone, current_user)
end
milestone
end
private
def before_create(milestone)
milestone.check_for_spam(user: current_user, action: :create)
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Milestones::CreateService, feature_category: :team_planning do
let_it_be(:user) { create(:user) }
let_it_be(:project) { create(:project) }
let_it_be(:params) { { title: 'New Milestone', description: 'Description' } }
subject(:create_milestone) { described_class.new(project, user, params) }
describe '#execute' do
context 'when milestone is saved successfully' do
it 'creates a new milestone' do
expect { create_milestone.execute }.to change { Milestone.count }.by(1)
end
it 'opens the milestone if it is a project milestone' do
expect_next_instance_of(EventCreateService) do |instance|
expect(instance).to receive(:open_milestone)
end
create_milestone.execute
end
it 'returns the created milestone' do
milestone = create_milestone.execute
expect(milestone).to be_a(Milestone)
expect(milestone.title).to eq('New Milestone')
expect(milestone.description).to eq('Description')
end
end
context 'when milestone fails to save' do
before do
allow_next_instance_of(Milestone) do |instance|
allow(instance).to receive(:save).and_return(false)
end
end
it 'does not create a new milestone' do
expect { create_milestone.execute }.not_to change { Milestone.count }
end
it 'does not open the milestone' do
expect(EventCreateService).not_to receive(:open_milestone)
create_milestone.execute
end
it 'returns the unsaved milestone' do
milestone = create_milestone.execute
expect(milestone).to be_a(Milestone)
expect(milestone.title).to eq('New Milestone')
expect(milestone.persisted?).to be_falsey
end
end
it 'calls before_create method' do
expect(create_milestone).to receive(:before_create)
create_milestone.execute
end
end
describe '#before_create' do
it 'checks for spam' do
milestone = build(:milestone)
expect(milestone).to receive(:check_for_spam).with(user: user, action: :create)
subject.send(:before_create, milestone)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Applications
class CreateService
attr_reader :current_user, :params
def initialize(current_user, params)
@current_user = current_user
@params = params.except(:ip_address)
end
# EE would override and use `request` arg
def execute(request)
@application = Doorkeeper::Application.new(params)
unless params[:scopes].present?
@application.errors.add(:base, _("Scopes can't be blank"))
return @application
end
@application.save
@application
end
end
end
Applications::CreateService.prepend_mod_with('Applications::CreateService')
``` | # frozen_string_literal: true
require "spec_helper"
RSpec.describe ::Applications::CreateService do
include TestRequestHelpers
let(:user) { create(:user) }
subject { described_class.new(user, params) }
context 'when scopes are present' do
let(:params) { attributes_for(:application, scopes: ['read_user']) }
it { expect { subject.execute(test_request) }.to change { Doorkeeper::Application.count }.by(1) }
end
context 'when scopes are missing' do
let(:params) { attributes_for(:application) }
it { expect { subject.execute(test_request) }.not_to change { Doorkeeper::Application.count } }
it 'includes blank scopes error message' do
application = subject.execute(test_request)
expect(application.errors.full_messages).to include "Scopes can't be blank"
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module JiraConnect
class CreateAsymmetricJwtService
ARGUMENT_ERROR_MESSAGE = 'jira_connect_installation is not a proxy installation'
def initialize(jira_connect_installation, event: :installed)
raise ArgumentError, ARGUMENT_ERROR_MESSAGE unless jira_connect_installation.proxy?
@jira_connect_installation = jira_connect_installation
@event = event
end
def execute
JWT.encode(jwt_claims, private_key, 'RS256', jwt_headers)
end
private
def jwt_claims
{ aud: aud_claim, iss: iss_claim, qsh: qsh_claim }
end
def aud_claim
@jira_connect_installation.audience_url
end
def iss_claim
@jira_connect_installation.client_key
end
def qsh_claim
Atlassian::Jwt.create_query_string_hash(
audience_event_url,
'POST',
@jira_connect_installation.audience_url
)
end
def audience_event_url
return @jira_connect_installation.audience_uninstalled_event_url if @event == :uninstalled
@jira_connect_installation.audience_installed_event_url
end
def private_key
@private_key ||= OpenSSL::PKey::RSA.generate(3072)
end
def public_key_storage
@public_key_storage ||= JiraConnect::PublicKey.create!(key: private_key.public_key)
end
def jwt_headers
{ kid: public_key_storage.uuid }
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe JiraConnect::CreateAsymmetricJwtService, feature_category: :integrations do
describe '#execute' do
let_it_be(:jira_connect_installation) { create(:jira_connect_installation) }
let(:service) { described_class.new(jira_connect_installation) }
subject(:jwt_token) { service.execute }
it 'raises an error' do
expect { jwt_token }.to raise_error(ArgumentError, 'jira_connect_installation is not a proxy installation')
end
context 'with proxy installation' do
let_it_be(:jira_connect_installation) { create(:jira_connect_installation, instance_url: 'https://gitlab.test') }
let(:public_key_id) { Atlassian::Jwt.decode(jwt_token, nil, false, algorithm: 'RS256').last['kid'] }
let(:public_key_cdn) { 'https://gitlab.com/-/jira_connect/public_keys/' }
let(:event_url) { 'https://gitlab.test/-/jira_connect/events/installed' }
let(:jwt_verification_claims) do
{
aud: 'https://gitlab.test/-/jira_connect',
iss: jira_connect_installation.client_key,
qsh: Atlassian::Jwt.create_query_string_hash(event_url, 'POST', 'https://gitlab.test/-/jira_connect')
}
end
subject(:jwt_token) { service.execute }
shared_examples 'produces a valid JWT' do
it 'produces a valid JWT' do
public_key = OpenSSL::PKey.read(JiraConnect::PublicKey.find(public_key_id).key)
options = jwt_verification_claims.except(:qsh).merge({ verify_aud: true, verify_iss: true,
algorithm: 'RS256' })
decoded_token = Atlassian::Jwt.decode(jwt_token, public_key, true, options).first
expect(decoded_token).to eq(jwt_verification_claims.stringify_keys)
end
end
it 'stores the public key' do
expect { JiraConnect::PublicKey.find(public_key_id) }.not_to raise_error
end
it_behaves_like 'produces a valid JWT'
context 'with uninstalled event option' do
let(:service) { described_class.new(jira_connect_installation, event: :uninstalled) }
let(:event_url) { 'https://gitlab.test/-/jira_connect/events/uninstalled' }
it_behaves_like 'produces a valid JWT'
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module JiraConnect
class SyncService
def initialize(project)
self.project = project
end
# Parameters: see Atlassian::JiraConnect::Client#send_info
# Includes: update_sequence_id, commits, branches, merge_requests, pipelines
def execute(**args)
preload_reviewers_for_merge_requests(args[:merge_requests]) if args.key?(:merge_requests)
JiraConnectInstallation.for_project(project).flat_map do |installation|
client = Atlassian::JiraConnect::Client.new(installation.base_url, installation.shared_secret)
responses = client.send_info(project: project, **args)
responses.each { |r| log_response(r) }
end
end
private
attr_accessor :project
def log_response(response)
message = {
message: 'response from jira dev_info api',
integration: 'JiraConnect',
project_id: project.id,
project_path: project.full_path,
jira_response: response&.to_json
}
has_errors = response && (response['errorMessage'].present? || response['errorMessages'].present?)
if has_errors
logger.error(message)
else
logger.info(message)
end
end
def logger
Gitlab::IntegrationsLogger
end
def preload_reviewers_for_merge_requests(merge_requests)
ActiveRecord::Associations::Preloader.new(
records: merge_requests, associations: [:approvals, { merge_request_reviewers: :reviewer }]
).call
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe JiraConnect::SyncService, feature_category: :integrations do
include AfterNextHelpers
describe '#execute' do
let_it_be(:project) { create(:project, :repository) }
let_it_be(:merge_request) { create(:merge_request, source_project: project) }
let_it_be(:merge_request_reviewer) { create(:merge_request_reviewer, merge_request: merge_request) }
let(:client) { Atlassian::JiraConnect::Client }
let(:info) { { a: 'Some', b: 'Info', merge_requests: [merge_request] } }
subject do
described_class.new(project).execute(**info)
end
before do
create(:jira_connect_subscription, namespace: project.namespace)
end
def store_info(return_values = [{ 'status': 'success' }])
receive(:send_info).with(project: project, **info).and_return(return_values)
end
def expect_log(type, message)
expect(Gitlab::IntegrationsLogger)
.to receive(type).with(
{
message: 'response from jira dev_info api',
integration: 'JiraConnect',
project_id: project.id,
project_path: project.full_path,
jira_response: message&.to_json
}
)
end
it 'calls Atlassian::JiraConnect::Client#store_dev_info and logs the response' do
expect_next(client).to store_info
expect_log(:info, { 'status': 'success' })
subject
end
it 'does not execute any queries for preloaded reviewers' do
expect_next(client).to store_info
expect_log(:info, { 'status': 'success' })
amount = ActiveRecord::QueryRecorder
.new { info[:merge_requests].flat_map(&:merge_request_reviewers).map(&:reviewer) }
.count
expect(amount).to be_zero
subject
end
context 'when a request returns errors' do
it 'logs each response as an error' do
expect_next(client).to store_info(
[
{ 'errorMessages' => ['some error message'] },
{ 'errorMessage' => 'a single error message' },
{ 'errorMessages' => [] },
{ 'errorMessage' => '' }
])
expect_log(:error, { 'errorMessages' => ['some error message'] })
expect_log(:error, { 'errorMessage' => 'a single error message' })
subject
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Files
class BaseService < Commits::CreateService
FileChangedError = Class.new(StandardError)
def initialize(*args)
super
git_user = Gitlab::Git::User.from_gitlab(current_user) if current_user.present?
@author_email = commit_email(git_user)
@author_name = params[:author_name] || git_user&.name
@commit_message = params[:commit_message]
@last_commit_sha = params[:last_commit_sha]
@file_path = params[:file_path]
@previous_path = params[:previous_path]
@file_content = params[:file_content]
@file_content = Base64.decode64(@file_content) if params[:file_content_encoding] == 'base64'
@execute_filemode = params[:execute_filemode]
end
def file_has_changed?(path, commit_id)
return false unless commit_id
last_commit_from_branch = get_last_commit_for_path(ref: @start_branch, path: path)
return false unless last_commit_from_branch
last_commit_from_commit_id = get_last_commit_for_path(ref: commit_id, path: path)
return false unless last_commit_from_commit_id
last_commit_from_branch.sha != last_commit_from_commit_id.sha
end
private
def get_last_commit_for_path(ref:, path:)
Gitlab::Git::Commit.last_for_path(@start_project.repository, ref, path, literal_pathspec: true)
end
def commit_email(git_user)
return params[:author_email] if params[:author_email].present?
return unless current_user
namespace_commit_email = current_user.namespace_commit_email_for_project(@start_project)
return namespace_commit_email.email.email if namespace_commit_email
git_user.email
end
end
end
``` | # frozen_string_literal: true
require "spec_helper"
RSpec.describe Files::BaseService, feature_category: :source_code_management do
let_it_be(:group) { create(:group) }
let_it_be(:project) { create(:project, group: group) }
let_it_be(:user) { create(:user) }
let(:params) { {} }
subject(:author_email) { described_class.new(project, user, params).instance_variable_get(:@author_email) }
before do
group.add_developer(user)
end
context 'with no namespace_commit_emails' do
it 'sets @author_email to user default email' do
expect(author_email).to eq(user.email)
end
end
context 'with an author_email in params and namespace_commit_email' do
let(:params) { { author_email: '[email protected]' } }
before do
create(:namespace_commit_email, user: user, namespace: group)
end
it 'gives precedence to the parameter value for @author_email' do
expect(author_email).to eq('[email protected]')
end
end
context 'with a project namespace_commit_email' do
it 'sets @author_email to the project namespace_commit_email' do
namespace_commit_email = create(:namespace_commit_email, user: user, namespace: project.project_namespace)
expect(author_email).to eq(namespace_commit_email.email.email)
end
end
context 'with a group namespace_commit_email' do
it 'sets @author_email to the group namespace_commit_email' do
namespace_commit_email = create(:namespace_commit_email, user: user, namespace: group)
expect(author_email).to eq(namespace_commit_email.email.email)
end
end
context 'with a project and group namespace_commit_email' do
it 'sets @author_email to the project namespace_commit_email' do
namespace_commit_email = create(:namespace_commit_email, user: user, namespace: project.project_namespace)
create(:namespace_commit_email, user: user, namespace: group)
expect(author_email).to eq(namespace_commit_email.email.email)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Files
class MultiService < Files::BaseService
UPDATE_FILE_ACTIONS = %w[update move delete chmod].freeze
def create_commit!
transformer = Lfs::FileTransformer.new(project, repository, @branch_name)
actions = actions_after_lfs_transformation(transformer, params[:actions])
actions = transform_move_actions(actions)
commit_actions!(actions)
end
private
def actions_after_lfs_transformation(transformer, actions)
actions.map do |action|
if action[:action] == 'create'
result = transformer.new_file(action[:file_path], action[:content], encoding: action[:encoding])
action[:content] = result.content
action[:encoding] = result.encoding
end
action
end
end
# When moving a file, `content: nil` means "use the contents of the previous
# file", while `content: ''` means "move the file and set it to empty"
def transform_move_actions(actions)
actions.map do |action|
action[:infer_content] = true if action[:content].nil?
action
end
end
def commit_actions!(actions)
repository.commit_files(
current_user,
message: @commit_message,
branch_name: @branch_name,
actions: actions,
author_email: @author_email,
author_name: @author_name,
start_project: @start_project,
start_branch_name: @start_branch,
start_sha: @start_sha,
force: force?
)
rescue ArgumentError => e
raise_error(e)
end
def validate!
super
params[:actions].each { |action| validate_file_status!(action) }
end
def validate_file_status!(action)
return unless UPDATE_FILE_ACTIONS.include?(action[:action])
file_path = action[:previous_path] || action[:file_path]
if file_has_changed?(file_path, action[:last_commit_id])
raise_error("The file has changed since you started editing it: #{file_path}")
end
end
end
end
``` | # frozen_string_literal: true
require "spec_helper"
RSpec.describe Files::MultiService, feature_category: :source_code_management do
subject { described_class.new(project, user, commit_params) }
let(:project) { create(:project, :repository) }
let(:repository) { project.repository }
let(:user) { create(:user) }
let(:branch_name) { project.default_branch }
let(:original_file_path) { 'files/ruby/popen.rb' }
let(:new_file_path) { 'files/ruby/popen.rb' }
let(:file_content) { 'New content' }
let(:action) { 'update' }
let(:commit_message) { 'Update File' }
let!(:original_commit_id) do
Gitlab::Git::Commit.last_for_path(project.repository, branch_name, original_file_path).sha
end
let(:branch_commit_id) do
Gitlab::Git::Commit.find(project.repository, branch_name).sha
end
let(:default_action) do
{
action: action,
file_path: new_file_path,
previous_path: original_file_path,
content: file_content,
last_commit_id: original_commit_id
}
end
let(:actions) { [default_action] }
let(:commit_params) do
{
commit_message: commit_message,
branch_name: branch_name,
start_branch: branch_name,
actions: actions
}
end
before do
project.add_maintainer(user)
end
describe '#execute' do
context 'with a valid action' do
it 'returns a hash with the :success status' do
results = subject.execute
expect(results[:status]).to eq(:success)
end
end
context 'with an invalid action' do
let(:action) { 'rename' }
it 'returns a hash with the :error status' do
results = subject.execute
expect(results[:status]).to eq(:error)
expect(results[:message]).to match(/Unknown action/)
end
end
describe 'Updating files' do
context 'when the file has been previously updated' do
before do
update_file(original_file_path)
end
it 'rejects the commit' do
results = subject.execute
expect(results[:status]).to eq(:error)
expect(results[:message]).to match(new_file_path)
end
end
context 'when file not changed, but later commit id is used' do
let(:actions) { [default_action.merge(last_commit_id: branch_commit_id)] }
it 'accepts the commit' do
results = subject.execute
expect(results[:status]).to eq(:success)
end
end
context 'when the file have not been modified' do
it 'accepts the commit' do
results = subject.execute
expect(results[:status]).to eq(:success)
end
end
end
describe 'changing execute_filemode of a file' do
let(:commit_message) { 'Chmod +x file' }
let(:file_path) { original_file_path }
let(:default_action) do
{
action: 'chmod',
file_path: file_path,
execute_filemode: true
}
end
it 'accepts the commit' do
results = subject.execute
expect(results[:status]).to eq(:success)
end
it 'updates the execute_filemode of the file' do
expect { subject.execute }.to change { repository.blob_at_branch(branch_name, file_path).mode }.from('100644').to('100755')
end
context "when the file doesn't exists" do
let(:file_path) { 'files/wrong_path.rb' }
it 'rejects the commit' do
results = subject.execute
expect(results[:status]).to eq(:error)
expect(results[:message]).to eq("A file with this name doesn't exist")
end
end
end
context 'when moving a file' do
let(:action) { 'move' }
let(:new_file_path) { 'files/ruby/new_popen.rb' }
let(:result) { subject.execute }
let(:blob) { repository.blob_at_branch(branch_name, new_file_path) }
context 'when original file has been updated' do
before do
update_file(original_file_path)
end
it 'rejects the commit' do
expect(result[:status]).to eq(:error)
expect(result[:message]).to match(original_file_path)
end
end
context 'when original file has not been updated' do
it 'moves the file' do
expect(result[:status]).to eq(:success)
expect(blob).to be_present
expect(blob.data).to eq(file_content)
end
context 'when content is nil' do
let(:file_content) { nil }
it 'moves the existing content untouched' do
original_content = repository.blob_at_branch(branch_name, original_file_path).data
expect(result[:status]).to eq(:success)
expect(blob).to be_present
expect(blob.data).to eq(original_content)
end
end
context 'when content is an empty string' do
let(:file_content) { '' }
it 'moves the file and empties it' do
expect(result[:status]).to eq(:success)
expect(blob).not_to be_nil
expect(blob.data).to eq('')
end
end
end
end
context 'when creating a file matching an LFS filter' do
let(:action) { 'create' }
let(:branch_name) { 'lfs' }
let(:new_file_path) { 'test_file.lfs' }
before do
allow(project).to receive(:lfs_enabled?).and_return(true)
end
it 'creates an LFS pointer' do
subject.execute
blob = repository.blob_at('lfs', new_file_path)
expect(blob.data).to start_with(Gitlab::Git::LfsPointerFile::VERSION_LINE)
end
it "creates an LfsObject with the file's content" do
subject.execute
expect(LfsObject.last.file.read).to eq file_content
end
context 'with base64 encoded content' do
let(:raw_file_content) { 'Raw content' }
let(:file_content) { Base64.encode64(raw_file_content) }
let(:actions) { [default_action.merge(encoding: 'base64')] }
it 'creates an LFS pointer' do
subject.execute
blob = repository.blob_at('lfs', new_file_path)
expect(blob.data).to start_with(Gitlab::Git::LfsPointerFile::VERSION_LINE)
end
it "creates an LfsObject with the file's content" do
subject.execute
expect(LfsObject.last.file.read).to eq raw_file_content
end
end
it 'links the LfsObject to the project' do
expect do
subject.execute
end.to change { project.lfs_objects.count }.by(1)
end
end
context 'when file status validation is skipped' do
let(:action) { 'create' }
let(:new_file_path) { 'files/ruby/new_file.rb' }
it 'does not check the last commit' do
expect(Gitlab::Git::Commit).not_to receive(:last_for_path)
subject.execute
end
it 'creates the file' do
subject.execute
blob = project.repository.blob_at_branch(branch_name, new_file_path)
expect(blob).to be_present
end
end
context 'when force is set to true and branch already exists' do
let(:commit_params) do
{
commit_message: commit_message,
branch_name: 'feature',
start_branch: 'master',
actions: actions,
force: true
}
end
it 'is still a success' do
expect(subject.execute[:status]).to eq(:success)
end
end
end
def update_file(path)
params = {
file_path: path,
start_branch: branch_name,
branch_name: branch_name,
commit_message: 'Update file',
file_content: 'New content'
}
Files::UpdateService.new(project, user, params).execute
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Files
class UpdateService < Files::BaseService
def create_commit!
repository.update_file(
current_user,
@file_path,
@file_content,
message: @commit_message,
branch_name: @branch_name,
previous_path: @previous_path,
author_email: @author_email,
author_name: @author_name,
start_project: @start_project,
start_branch_name: @start_branch,
execute_filemode: @execute_filemode
)
end
private
def validate!
super
if file_has_changed?(@file_path, @last_commit_sha)
raise FileChangedError, _('You are attempting to update a file that has changed since you started editing it.')
end
end
end
end
``` | # frozen_string_literal: true
require "spec_helper"
RSpec.describe Files::UpdateService, feature_category: :source_code_management do
subject { described_class.new(project, user, commit_params) }
let(:project) { create(:project, :repository) }
let(:user) { create(:user, :commit_email) }
let(:file_path) { 'files/ruby/popen.rb' }
let(:new_contents) { 'New Content' }
let(:branch_name) { project.default_branch }
let(:last_commit_sha) { nil }
let(:commit) { project.repository.commit }
let(:commit_params) do
{
file_path: file_path,
commit_message: "Update File",
file_content: new_contents,
file_content_encoding: "text",
last_commit_sha: last_commit_sha,
start_project: project,
start_branch: project.default_branch,
branch_name: branch_name
}
end
before do
project.add_maintainer(user)
end
describe "#execute" do
context "when the file's last commit sha is earlier than the latest change for that branch" do
let(:last_commit_sha) { Gitlab::Git::Commit.last_for_path(project.repository, project.default_branch, file_path).parent_id }
it "returns a hash with the correct error message and a :error status" do
expect { subject.execute }
.to raise_error(
Files::UpdateService::FileChangedError,
"You are attempting to update a file that has changed since you started editing it."
)
end
end
context "when the file's last commit sha does match the supplied last_commit_sha" do
let(:last_commit_sha) { Gitlab::Git::Commit.last_for_path(project.repository, project.default_branch, file_path).sha }
it "returns a hash with the :success status" do
results = subject.execute
expect(results[:status]).to match(:success)
end
it "updates the file with the new contents" do
subject.execute
results = project.repository.blob_at_branch(project.default_branch, file_path)
expect(results.data).to eq(new_contents)
end
it 'uses the commit email' do
subject.execute
expect(user.commit_email).not_to eq(user.email)
expect(commit.author_email).to eq(user.commit_email)
expect(commit.committer_email).to eq(user.commit_email)
end
end
context "when the last_commit_sha is not supplied" do
it "returns a hash with the :success status" do
results = subject.execute
expect(results[:status]).to match(:success)
end
it "updates the file with the new contents" do
subject.execute
results = project.repository.blob_at_branch(project.default_branch, file_path)
expect(results.data).to eq(new_contents)
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Files
class CreateService < Files::BaseService
def create_commit!
transformer = Lfs::FileTransformer.new(project, repository, @branch_name)
result = transformer.new_file(@file_path, @file_content)
create_transformed_commit(result.content)
end
private
def create_transformed_commit(content_or_lfs_pointer)
repository.create_file(
current_user,
@file_path,
content_or_lfs_pointer,
message: @commit_message,
branch_name: @branch_name,
author_email: @author_email,
author_name: @author_name,
start_project: @start_project,
start_branch_name: @start_branch,
execute_filemode: @execute_filemode)
end
end
end
``` | # frozen_string_literal: true
require "spec_helper"
RSpec.describe Files::CreateService, feature_category: :source_code_management do
let(:project) { create(:project, :repository) }
let(:repository) { project.repository }
let(:user) { create(:user, :commit_email) }
let(:file_content) { 'Test file content' }
let(:branch_name) { project.default_branch }
let(:start_branch) { branch_name }
let(:commit_params) do
{
file_path: file_path,
commit_message: "Update File",
file_content: file_content,
file_content_encoding: "text",
start_project: project,
start_branch: start_branch,
branch_name: branch_name
}
end
let(:commit) { repository.head_commit }
subject { described_class.new(project, user, commit_params) }
before do
project.add_maintainer(user)
end
describe "#execute" do
context 'when file matches LFS filter' do
let(:file_path) { 'test_file.lfs' }
let(:branch_name) { 'lfs' }
context 'with LFS disabled' do
it 'skips gitattributes check' do
expect(repository).not_to receive(:attributes_at)
subject.execute
end
it "doesn't create LFS pointers" do
subject.execute
blob = repository.blob_at('lfs', file_path)
expect(blob.data).not_to start_with(Gitlab::Git::LfsPointerFile::VERSION_LINE)
expect(blob.data).to eq(file_content)
end
end
context 'with LFS enabled' do
before do
allow(project).to receive(:lfs_enabled?).and_return(true)
end
it 'creates an LFS pointer' do
subject.execute
blob = repository.blob_at('lfs', file_path)
expect(blob.data).to start_with(Gitlab::Git::LfsPointerFile::VERSION_LINE)
end
it "creates an LfsObject with the file's content" do
subject.execute
expect(LfsObject.last.file.read).to eq file_content
end
it 'links the LfsObject to the project' do
expect do
subject.execute
end.to change { project.lfs_objects.count }.by(1)
end
end
end
end
context 'commit attribute' do
let(:file_path) { 'test-commit-attributes.txt' }
it 'uses the commit email' do
subject.execute
expect(user.commit_email).not_to eq(user.email)
expect(commit.author_email).to eq(user.commit_email)
expect(commit.committer_email).to eq(user.commit_email)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Files
class DeleteService < Files::BaseService
def create_commit!
repository.delete_file(
current_user,
@file_path,
message: @commit_message,
branch_name: @branch_name,
author_email: @author_email,
author_name: @author_name,
start_project: @start_project,
start_branch_name: @start_branch)
end
private
def validate!
super
if file_has_changed?(@file_path, @last_commit_sha)
raise FileChangedError, _("You are attempting to delete a file that has been previously updated.")
end
end
end
end
``` | # frozen_string_literal: true
require "spec_helper"
RSpec.describe Files::DeleteService, feature_category: :source_code_management do
subject { described_class.new(project, user, commit_params) }
let(:project) { create(:project, :repository) }
let(:user) { create(:user, :commit_email) }
let(:file_path) { 'files/ruby/popen.rb' }
let(:branch_name) { project.default_branch }
let(:last_commit_sha) { nil }
let(:commit) { project.repository.head_commit }
let(:commit_params) do
{
file_path: file_path,
commit_message: "Delete File",
last_commit_sha: last_commit_sha,
start_project: project,
start_branch: project.default_branch,
branch_name: branch_name
}
end
shared_examples 'successfully deletes the file' do
it 'returns a hash with the :success status' do
results = subject.execute
expect(results[:status]).to match(:success)
end
it 'deletes the file' do
subject.execute
blob = project.repository.blob_at_branch(project.default_branch, file_path)
expect(blob).to be_nil
end
it 'uses the commit email' do
subject.execute
expect(user.commit_email).not_to eq(user.email)
expect(commit.author_email).to eq(user.commit_email)
expect(commit.committer_email).to eq(user.commit_email)
end
end
before do
project.add_maintainer(user)
end
describe "#execute" do
context "when the file's last commit is earlier than the latest commit for this branch" do
let(:last_commit_sha) { Gitlab::Git::Commit.last_for_path(project.repository, project.default_branch, file_path).parent_id }
it "returns a hash with the correct error message and a :error status" do
expect { subject.execute }.to raise_error(
Files::UpdateService::FileChangedError,
"You are attempting to delete a file that has been previously updated."
)
end
end
context "when the file's last commit sha does match the supplied last_commit_sha" do
let(:last_commit_sha) { Gitlab::Git::Commit.last_for_path(project.repository, project.default_branch, file_path).sha }
it_behaves_like 'successfully deletes the file'
end
context "when the last_commit_sha is not supplied" do
it_behaves_like 'successfully deletes the file'
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WikiPages
# There are 3 notions of 'action' that inheriting classes must implement:
#
# - external_action: the action we report to external clients with webhooks
# - usage_counter_action: the action that we count in out internal counters
# - event_action: what we record as the value of `Event#action`
class BaseService < ::BaseContainerService
private
def execute_hooks(page)
page_data = payload(page)
container.execute_hooks(page_data, :wiki_page_hooks)
container.execute_integrations(page_data, :wiki_page_hooks)
increment_usage
create_wiki_event(page)
end
# Passed to web-hooks, and send to external consumers.
def external_action
raise NotImplementedError
end
# Passed to the WikiPageCounter to count events.
# Must be one of WikiPageCounter::KNOWN_EVENTS
def usage_counter_action
raise NotImplementedError
end
# Used to create `Event` records.
# Must be a valid value for `Event#action`
def event_action
raise NotImplementedError
end
def payload(page)
Gitlab::DataBuilder::WikiPage.build(page, current_user, external_action)
end
# This method throws an error if the action is an unanticipated value.
def increment_usage
Gitlab::UsageDataCounters::WikiPageCounter.count(usage_counter_action)
end
def create_wiki_event(page)
response = WikiPages::EventCreateService
.new(current_user)
.execute(slug_for_page(page), page, event_action, fingerprint(page))
log_error(response.message) if response.error?
end
def slug_for_page(page)
page.slug
end
def fingerprint(page)
page.sha
end
end
end
WikiPages::BaseService.prepend_mod_with('WikiPages::BaseService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WikiPages::BaseService, feature_category: :wiki do
let(:project) { double('project') }
let(:user) { double('user') }
describe '#increment_usage' do
counter = Gitlab::UsageDataCounters::WikiPageCounter
error = counter::UnknownEvent
let(:subject) { bad_service_class.new(container: project, current_user: user) }
context 'the class implements usage_counter_action incorrectly' do
let(:bad_service_class) do
Class.new(described_class) do
def usage_counter_action
:bad_event
end
end
end
it 'raises an error on unknown events' do
expect { subject.send(:increment_usage) }.to raise_error(error)
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WikiPages
class EventCreateService
# @param [User] author The event author
def initialize(author)
raise ArgumentError, 'author must not be nil' unless author
@author = author
end
def execute(slug, page, action, event_fingerprint)
wiki_page_meta = WikiPage::Meta.find_or_create(slug, page)
event = ::EventCreateService.new.wiki_event(wiki_page_meta, author, action, event_fingerprint)
ServiceResponse.success(payload: { event: event })
rescue ::EventCreateService::IllegalActionError, ::ActiveRecord::ActiveRecordError => e
ServiceResponse.error(message: e.message, payload: { error: e })
end
private
attr_reader :author
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WikiPages::EventCreateService, feature_category: :wiki do
let_it_be(:project) { create(:project) }
let_it_be(:user) { create(:user) }
subject { described_class.new(user) }
describe '#execute' do
let_it_be(:page) { create(:wiki_page, project: project) }
let(:slug) { generate(:sluggified_title) }
let(:action) { :created }
let(:fingerprint) { page.sha }
let(:response) { subject.execute(slug, page, action, fingerprint) }
context 'the user is nil' do
subject { described_class.new(nil) }
it 'raises an error on construction' do
expect { subject }.to raise_error ArgumentError
end
end
context 'the action is illegal' do
let(:action) { :illegal_action }
it 'returns an error' do
expect(response).to be_error
end
it 'does not create an event' do
expect { response }.not_to change(Event, :count)
end
end
it 'returns a successful response' do
expect(response).to be_success
end
context 'the action is a deletion' do
let(:action) { :destroyed }
it 'does not synchronize the wiki metadata timestamps with the git commit' do
expect_next_instance_of(WikiPage::Meta) do |instance|
expect(instance).not_to receive(:synch_times_with_page)
end
response
end
end
it 'creates a wiki page event' do
expect { response }.to change(Event, :count).by(1)
end
it 'returns an event in the payload' do
expect(response.payload).to include(event: have_attributes(author: user, wiki_page?: true, action: 'created'))
end
it 'records the slug for the page' do
response
meta = WikiPage::Meta.find_or_create(page.slug, page)
expect(meta.slugs.pluck(:slug)).to include(slug)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WikiPages
class DestroyService < WikiPages::BaseService
def execute(page)
if page.delete
execute_hooks(page)
ServiceResponse.success(payload: { page: page })
else
ServiceResponse.error(
message: _('Could not delete wiki page'), payload: { page: page }
)
end
end
def usage_counter_action
:delete
end
def external_action
'delete'
end
def event_action
:destroyed
end
def fingerprint(page)
page.wiki.repository.head_commit.sha
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WikiPages::DestroyService, feature_category: :wiki do
it_behaves_like 'WikiPages::DestroyService#execute', :project
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WikiPages
class UpdateService < WikiPages::BaseService
UpdateError = Class.new(StandardError)
def execute(page)
# this class is not thread safe!
@old_slug = page.slug
if page.wiki.capture_git_error(event_action) { page.update(@params) }
execute_hooks(page)
ServiceResponse.success(payload: { page: page })
else
raise UpdateError, _('Could not update wiki page')
end
rescue UpdateError, WikiPage::PageChangedError, WikiPage::PageRenameError => e
page.update_attributes(@params) # rubocop:disable Rails/ActiveRecordAliases
ServiceResponse.error(
message: e.message,
payload: { page: page }
)
end
def usage_counter_action
:update
end
def external_action
'update'
end
def event_action
:updated
end
def slug_for_page(page)
@old_slug.presence || super
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WikiPages::UpdateService, feature_category: :wiki do
it_behaves_like 'WikiPages::UpdateService#execute', :project
describe '#execute' do
let_it_be(:project) { create(:project) }
let(:page) { create(:wiki_page, project: project) }
subject(:service) { described_class.new(container: project) }
context 'when wiki create fails due to git error' do
let(:wiki_git_error) { 'Could not update wiki page' }
it 'catches the thrown error and returns a ServiceResponse error' do
allow_next_instance_of(WikiPage) do |instance|
allow(instance).to receive(:update).and_raise(Gitlab::Git::CommandError.new(wiki_git_error))
end
result = service.execute(page)
expect(result).to be_error
expect(result.message).to eq(wiki_git_error)
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module WikiPages
class CreateService < WikiPages::BaseService
def execute
wiki = Wiki.for_container(container, current_user)
page = WikiPage.new(wiki)
wiki.capture_git_error(event_action) do
page.create(@params)
end
if page.persisted?
execute_hooks(page)
ServiceResponse.success(payload: { page: page })
else
ServiceResponse.error(message: _('Could not create wiki page'), payload: { page: page })
end
end
def usage_counter_action
:create
end
def external_action
'create'
end
def event_action
:created
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe WikiPages::CreateService, feature_category: :wiki do
it_behaves_like 'WikiPages::CreateService#execute', :project
describe '#execute' do
let_it_be(:project) { create(:project) }
subject(:service) { described_class.new(container: project) }
context 'when wiki create fails due to git error' do
let(:wiki_git_error) { 'Could not create wiki page' }
it 'catches the thrown error and returns a ServiceResponse error' do
allow_next_instance_of(WikiPage) do |instance|
allow(instance).to receive(:create).and_raise(Gitlab::Git::CommandError.new(wiki_git_error))
end
result = service.execute
expect(result).to be_error
expect(result.message).to eq(wiki_git_error)
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Lfs
# Lfs::PushService pushes the LFS objects associated with a project to a
# remote URL
class PushService < BaseService
include Gitlab::Utils::StrongMemoize
# Match the canonical LFS client's batch size:
# https://github.com/git-lfs/git-lfs/blob/master/tq/transfer_queue.go#L19
BATCH_SIZE = 100
def execute
lfs_objects_relation.each_batch(of: BATCH_SIZE) do |objects|
push_objects!(objects)
end
success
rescue StandardError => err
Gitlab::ErrorTracking.log_exception(err, extra_context)
error(err.message)
end
private
def extra_context
{ project_id: project.id, user_id: current_user&.id }.compact
end
# Currently we only set repository_type for design repository objects, so
# push mirroring must send objects with a `nil` repository type - but if the
# wiki repository uses LFS, its objects will also be sent. This will be
# addressed by https://gitlab.com/gitlab-org/gitlab/-/issues/250346
def lfs_objects_relation
project.lfs_objects_for_repository_types(nil, :project)
end
def push_objects!(objects)
rsp = lfs_client.batch!('upload', objects)
objects = objects.index_by(&:oid)
rsp.fetch('objects', []).each do |spec|
actions = spec['actions']
object = objects[spec['oid']]
upload_object!(object, spec) if actions&.key?('upload')
verify_object!(object, spec) if actions&.key?('verify')
end
end
def upload_object!(object, spec)
authenticated = spec['authenticated']
upload = spec.dig('actions', 'upload')
# The server wants us to upload the object but something is wrong
unless object && object.size == spec['size'].to_i
log_error("Couldn't match object #{spec['oid']}/#{spec['size']}")
return
end
lfs_client.upload!(object, upload, authenticated: authenticated)
end
def verify_object!(object, spec)
authenticated = spec['authenticated']
verify = spec.dig('actions', 'verify')
lfs_client.verify!(object, verify, authenticated: authenticated)
end
def url
params.fetch(:url)
end
def credentials
params.fetch(:credentials)
end
def lfs_client
strong_memoize(:lfs_client) do
Gitlab::Lfs::Client.new(url, credentials: credentials)
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Lfs::PushService, feature_category: :source_code_management do
let(:logger) { service.send(:logger) }
let(:lfs_client) { service.send(:lfs_client) }
let_it_be(:project) { create(:forked_project_with_submodules) }
let_it_be(:remote_mirror) { create(:remote_mirror, project: project, enabled: true) }
let(:params) { { url: remote_mirror.bare_url, credentials: remote_mirror.credentials } }
subject(:service) { described_class.new(project, nil, params) }
describe "#execute" do
let_it_be(:lfs_object) { create_linked_lfs_object(project, :project) }
it 'uploads the object when upload is requested' do
stub_lfs_batch(lfs_object)
expect(lfs_client)
.to receive(:upload!)
.with(lfs_object, upload_action_spec(lfs_object), authenticated: true)
expect(service.execute).to eq(status: :success)
end
it 'does not upload the object when upload is not requested' do
stub_lfs_batch(lfs_object, upload: false)
expect(lfs_client).not_to receive(:upload!)
expect(service.execute).to eq(status: :success)
end
it 'verifies the upload if requested' do
stub_lfs_batch(lfs_object, verify: true)
expect(lfs_client).to receive(:upload!)
expect(lfs_client)
.to receive(:verify!)
.with(lfs_object, verify_action_spec(lfs_object), authenticated: true)
expect(service.execute).to eq(status: :success)
end
it 'skips verification if requested but upload fails' do
stub_lfs_batch(lfs_object, verify: true)
expect(lfs_client).to receive(:upload!) { raise 'failed' }
expect(lfs_client).not_to receive(:verify!)
expect(service.execute).to eq(status: :error, message: 'failed')
end
it 'returns a failure when submitting a batch fails' do
expect(lfs_client).to receive(:batch!) { raise 'failed' }
expect(Gitlab::ErrorTracking).to receive(:log_exception).and_call_original
expect(service.execute).to eq(status: :error, message: 'failed')
end
it 'returns a failure when submitting an upload fails' do
stub_lfs_batch(lfs_object)
expect(lfs_client).to receive(:upload!) { raise 'failed' }
expect(Gitlab::ErrorTracking).to receive(:log_exception).and_call_original
expect(service.execute).to eq(status: :error, message: 'failed')
end
context 'non-project-repository LFS objects' do
let_it_be(:nil_lfs_object) { create_linked_lfs_object(project, nil) }
let_it_be(:wiki_lfs_object) { create_linked_lfs_object(project, :wiki) }
let_it_be(:design_lfs_object) { create_linked_lfs_object(project, :design) }
it 'only tries to upload the project-repository LFS object' do
stub_lfs_batch(nil_lfs_object, lfs_object, upload: false)
expect(service.execute).to eq(status: :success)
end
end
end
it 'does nothing if there are no LFS objects' do
expect(lfs_client).not_to receive(:upload!)
expect(service.execute).to eq(status: :success)
end
def create_linked_lfs_object(project, type)
create(:lfs_objects_project, project: project, repository_type: type).lfs_object
end
def stub_lfs_batch(*objects, upload: true, verify: false)
expect(lfs_client)
.to receive(:batch!).with('upload', containing_exactly(*objects))
.and_return('transfer' => 'basic', 'objects' => objects.map { |o| object_spec(o, upload: upload, verify: verify) })
end
def batch_spec(*objects, upload: true, verify: false)
{ 'transfer' => 'basic', 'objects' => objects.map { |o| object_spec(o, upload: upload) } }
end
def object_spec(object, upload: true, verify: false)
{ 'oid' => object.oid, 'size' => object.size, 'authenticated' => true, 'actions' => {} }.tap do |spec|
spec['actions']['upload'] = upload_action_spec(object) if upload
spec['actions']['verify'] = verify_action_spec(object) if verify
end
end
def upload_action_spec(object)
{ 'href' => "https://example.com/#{object.oid}/#{object.size}", 'header' => { 'Key' => 'value' } }
end
def verify_action_spec(object)
{ 'href' => "https://example.com/#{object.oid}/#{object.size}/verify", 'header' => { 'Key' => 'value' } }
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Lfs
class UnlockFileService < BaseService
def execute
unless can?(current_user, :push_code, project)
raise Gitlab::GitAccess::ForbiddenError, _('You have no permissions')
end
unlock_file
rescue Gitlab::GitAccess::ForbiddenError => ex
error(ex.message, 403)
rescue ActiveRecord::RecordNotFound
error(_('Lock not found'), 404)
rescue StandardError => ex
error(ex.message, 500)
end
private
def unlock_file
forced = params[:force] == true
if lock.can_be_unlocked_by?(current_user, forced)
lock.destroy!
success(lock: lock, http_status: :ok)
elsif forced
error(_('You must have maintainer access to force delete a lock'), 403)
else
error(_("%{lock_path} is locked by GitLab User %{lock_user_id}") % { lock_path: lock.path, lock_user_id: lock.user_id }, 403)
end
end
# rubocop: disable CodeReuse/ActiveRecord
def lock
return @lock if defined?(@lock)
@lock = if params[:id].present?
project.lfs_file_locks.find(params[:id])
elsif params[:path].present?
project.lfs_file_locks.find_by!(path: params[:path])
end
end
# rubocop: enable CodeReuse/ActiveRecord
end
end
Lfs::UnlockFileService.prepend_mod_with('Lfs::UnlockFileService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Lfs::UnlockFileService, feature_category: :source_code_management do
let(:project) { create(:project) }
let(:current_user) { create(:user) }
let(:lock_author) { create(:user) }
let!(:lock) { create(:lfs_file_lock, user: lock_author, project: project) }
let(:params) { {} }
subject { described_class.new(project, current_user, params) }
describe '#execute' do
context 'when not authorized' do
it "doesn't succeed" do
result = subject.execute
expect(result[:status]).to eq(:error)
expect(result[:http_status]).to eq(403)
expect(result[:message]).to eq(_('You have no permissions'))
end
end
context 'when authorized' do
before do
project.add_developer(current_user)
end
context 'when lock does not exists' do
let(:params) { { id: 123 } }
it "doesn't succeed" do
result = subject.execute
expect(result[:status]).to eq(:error)
expect(result[:http_status]).to eq(404)
end
end
context 'when unlocked by the author' do
let(:current_user) { lock_author }
let(:params) { { id: lock.id } }
it "succeeds" do
result = subject.execute
expect(result[:status]).to eq(:success)
expect(result[:lock]).to be_present
end
end
context 'when unlocked by a different user' do
let(:current_user) { create(:user) }
let(:params) { { id: lock.id } }
it "doesn't succeed" do
result = subject.execute
expect(result[:status]).to eq(:error)
expect(result[:message]).to match(/is locked by GitLab User #{lock_author.id}/)
expect(result[:http_status]).to eq(403)
end
end
context 'when forced' do
let(:developer) { create(:user) }
let(:maintainer) { create(:user) }
before do
project.add_developer(developer)
project.add_maintainer(maintainer)
end
context 'by a regular user' do
let(:current_user) { developer }
let(:params) do
{ id: lock.id,
force: true }
end
it "doesn't succeed" do
result = subject.execute
expect(result[:status]).to eq(:error)
expect(result[:message]).to eq(_('You must have maintainer access to force delete a lock'))
expect(result[:http_status]).to eq(403)
end
end
context 'by a maintainer user' do
let(:current_user) { maintainer }
let(:params) do
{ id: lock.id,
force: true }
end
it "succeeds" do
result = subject.execute
expect(result[:status]).to eq(:success)
expect(result[:lock]).to be_present
end
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Lfs
# Usage: Calling `new_file` check to see if a file should be in LFS and
# return a transformed result with `content` and `encoding` to commit.
#
# The `repository` passed to the initializer can be a Repository or
# class that inherits from Repository.
#
# The `repository_type` property will be one of the types named in
# `Gitlab::GlRepository.types`, and is recorded on the `LfsObjectsProject`
# in order to identify the repository location of the blob.
#
# For LFS an LfsObject linked to the project is stored and an LFS
# pointer returned. If the file isn't in LFS the untransformed content
# is returned to save in the commit.
#
# transformer = Lfs::FileTransformer.new(project, repository, @branch_name)
# content_or_lfs_pointer = transformer.new_file(file_path, content).content
# create_transformed_commit(content_or_lfs_pointer)
#
class FileTransformer
attr_reader :project, :repository, :repository_type, :branch_name
def initialize(project, repository, branch_name)
@project = project
@repository = repository
@repository_type = repository.repo_type.name
@branch_name = branch_name
end
def new_file(file_path, file_content, encoding: nil, detect_content_type: false)
if project.lfs_enabled? && lfs_file?(file_path)
file_content = parse_file_content(file_content, encoding: encoding)
lfs_pointer_file = Gitlab::Git::LfsPointerFile.new(file_content)
lfs_object = create_lfs_object!(lfs_pointer_file, file_content, detect_content_type)
link_lfs_object!(lfs_object)
Result.new(content: lfs_pointer_file.pointer, encoding: 'text')
else
Result.new(content: file_content, encoding: encoding)
end
end
class Result
attr_reader :content, :encoding
def initialize(content:, encoding:)
@content = content
@encoding = encoding
end
end
private
def lfs_file?(file_path)
cached_attributes.attributes(file_path)['filter'] == 'lfs'
end
def cached_attributes
@cached_attributes ||= repository.attributes_at(branch_name)
end
# rubocop: disable CodeReuse/ActiveRecord
def create_lfs_object!(lfs_pointer_file, file_content, detect_content_type)
LfsObject.find_or_create_by(oid: lfs_pointer_file.sha256, size: lfs_pointer_file.size) do |lfs_object|
lfs_object.file = if detect_content_type && (content_type = Gitlab::Utils::MimeType.from_string(file_content))
CarrierWaveStringFile.new_file(
file_content: file_content,
filename: '',
content_type: content_type
)
else
CarrierWaveStringFile.new(file_content)
end
end
end
# rubocop: enable CodeReuse/ActiveRecord
def link_lfs_object!(lfs_object)
LfsObjectsProject.safe_find_or_create_by!(
project: project,
lfs_object: lfs_object,
repository_type: repository_type
)
end
def parse_file_content(file_content, encoding: nil)
return file_content.read if file_content.respond_to?(:read)
return Base64.decode64(file_content) if encoding == 'base64'
file_content
end
end
end
``` | # frozen_string_literal: true
require "spec_helper"
RSpec.describe Lfs::FileTransformer, feature_category: :source_code_management do
let(:project) { create(:project, :repository, :wiki_repo) }
let(:repository) { project.repository }
let(:file_content) { 'Test file content' }
let(:branch_name) { 'lfs' }
let(:file_path) { 'test_file.lfs' }
subject { described_class.new(project, repository, branch_name) }
describe '#new_file' do
context 'with lfs disabled' do
before do
allow(project).to receive(:lfs_enabled?).and_return(false)
end
it 'skips gitattributes check' do
expect(repository.raw).not_to receive(:blob_at)
subject.new_file(file_path, file_content)
end
it 'returns untransformed content' do
result = subject.new_file(file_path, file_content)
expect(result.content).to eq(file_content)
end
it 'returns untransformed encoding' do
result = subject.new_file(file_path, file_content, encoding: 'base64')
expect(result.encoding).to eq('base64')
end
end
context 'with lfs enabled' do
before do
allow(project).to receive(:lfs_enabled?).and_return(true)
end
it 'reuses cached gitattributes' do
second_file = 'another_file.lfs'
expect(repository.raw).to receive(:blob_at).with(branch_name, '.gitattributes').once
subject.new_file(file_path, file_content)
subject.new_file(second_file, file_content)
end
it "creates an LfsObject with the file's content" do
subject.new_file(file_path, file_content)
expect(LfsObject.last.file.read).to eq file_content
end
it 'returns an LFS pointer' do
result = subject.new_file(file_path, file_content)
expect(result.content).to start_with(Gitlab::Git::LfsPointerFile::VERSION_LINE)
end
it 'returns LFS pointer encoding as text' do
result = subject.new_file(file_path, file_content, encoding: 'base64')
expect(result.encoding).to eq('text')
end
context 'when an actual file is passed' do
let(:file) { Tempfile.new(file_path) }
before do
file.write(file_content)
file.rewind
end
after do
file.unlink
end
it "creates an LfsObject with the file's content" do
subject.new_file(file_path, file)
expect(LfsObject.last.file.read).to eq file_content
end
context 'when repository is a design repository' do
let(:file_path) { "/#{DesignManagement.designs_directory}/test_file.lfs" }
let(:repository) { project.design_repository }
it "creates an LfsObject with the file's content" do
subject.new_file(file_path, file)
expect(LfsObject.last.file.read).to eq(file_content)
end
it 'saves the correct repository_type to LfsObjectsProject' do
subject.new_file(file_path, file)
expect(project.lfs_objects_projects.first.repository_type).to eq('design')
end
end
context 'when content type detection enabled' do
let(:detect_content_type) { true }
before do
allow(Gitlab::Utils::MimeType).to receive(:from_string).with(file_content).and_return(mime_type)
end
context 'when mime type detected' do
let(:mime_type) { 'image/tiff' }
it 'creates a file with custom content type' do
expect(CarrierWaveStringFile).to receive(:new_file).with({
file_content: file_content,
filename: anything,
content_type: mime_type
})
subject.new_file(file_path, file, detect_content_type: detect_content_type)
end
end
context 'when mime type not detected' do
let(:mime_type) { nil }
it 'creates a file with default content type' do
expect(CarrierWaveStringFile).to receive(:new).with(file_content)
subject.new_file(file_path, file, detect_content_type: detect_content_type)
end
end
end
end
context "when doesn't use LFS" do
let(:file_path) { 'other.filetype' }
it "doesn't create LFS pointers" do
new_content = subject.new_file(file_path, file_content).content
expect(new_content).not_to start_with(Gitlab::Git::LfsPointerFile::VERSION_LINE)
expect(new_content).to eq(file_content)
end
end
it 'links LfsObjects to project' do
expect do
subject.new_file(file_path, file_content)
end.to change { project.lfs_objects.count }.by(1)
end
it 'saves the repository_type to LfsObjectsProject' do
subject.new_file(file_path, file_content)
expect(project.lfs_objects_projects.first.repository_type).to eq('project')
end
context 'when LfsObject already exists' do
let(:lfs_pointer) { Gitlab::Git::LfsPointerFile.new(file_content) }
before do
create(:lfs_object, oid: lfs_pointer.sha256, size: lfs_pointer.size)
end
it 'links LfsObjects to project' do
expect do
subject.new_file(file_path, file_content)
end.to change { project.lfs_objects.count }.by(1)
end
end
context 'when the LfsObject is already linked to project' do
before do
subject.new_file(file_path, file_content)
end
shared_examples 'a new LfsObject is not created' do
it do
expect do
second_service.new_file(file_path, file_content)
end.not_to change { project.lfs_objects.count }
end
end
context 'and the service is called again with the same repository type' do
let(:second_service) { described_class.new(project, repository, branch_name) }
include_examples 'a new LfsObject is not created'
it 'does not create a new LfsObjectsProject record' do
expect do
second_service.new_file(file_path, file_content)
end.not_to change { project.lfs_objects_projects.count }
end
end
context 'and the service is called again with a different repository type' do
let(:second_service) { described_class.new(project, project.wiki.repository, branch_name) }
before do
expect(second_service).to receive(:lfs_file?).and_return(true)
end
include_examples 'a new LfsObject is not created'
it 'creates a new LfsObjectsProject record' do
expect do
second_service.new_file(file_path, file_content)
end.to change { project.lfs_objects_projects.count }.by(1)
end
it 'sets the correct repository_type on the new LfsObjectsProject record' do
second_service.new_file(file_path, file_content)
repository_types = project.lfs_objects_projects.order(:id).pluck(:repository_type)
expect(repository_types).to eq(%w[project wiki])
end
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Lfs
class LocksFinderService < BaseService
def execute
success(locks: find_locks)
rescue StandardError => ex
error(ex.message, 500)
end
private
# rubocop: disable CodeReuse/ActiveRecord
def find_locks
options = params.slice(:id, :path).to_h.compact.symbolize_keys
project.lfs_file_locks.where(options)
end
# rubocop: enable CodeReuse/ActiveRecord
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Lfs::LocksFinderService, feature_category: :source_code_management do
let(:project) { create(:project) }
let(:user) { create(:user) }
let(:params) { {} }
subject { described_class.new(project, user, params) }
shared_examples 'no results' do
it 'returns an empty list' do
result = subject.execute
expect(result[:status]).to eq(:success)
expect(result[:locks]).to be_blank
end
end
describe '#execute' do
let!(:lock_1) { create(:lfs_file_lock, project: project) }
let!(:lock_2) { create(:lfs_file_lock, project: project, path: 'README') }
context 'find by id' do
context 'with results' do
let(:params) do
{ id: lock_1.id }
end
it 'returns the record' do
result = subject.execute
expect(result[:status]).to eq(:success)
expect(result[:locks].size).to eq(1)
expect(result[:locks].first).to eq(lock_1)
end
end
context 'without results' do
let(:params) do
{ id: 123 }
end
include_examples 'no results'
end
end
context 'find by path' do
context 'with results' do
let(:params) do
{ path: lock_1.path }
end
it 'returns the record' do
result = subject.execute
expect(result[:status]).to eq(:success)
expect(result[:locks].size).to eq(1)
expect(result[:locks].first).to eq(lock_1)
end
end
context 'without results' do
let(:params) do
{ path: 'not-found' }
end
include_examples 'no results'
end
end
context 'find all' do
context 'with results' do
it 'returns all the records' do
result = subject.execute
expect(result[:status]).to eq(:success)
expect(result[:locks].size).to eq(2)
end
end
context 'without results' do
before do
LfsFileLock.delete_all
end
include_examples 'no results'
end
end
context 'when an error is raised' do
it "doesn't succeed" do
allow_next_instance_of(described_class) do |instance|
allow(instance).to receive(:find_locks).and_raise(StandardError)
end
result = subject.execute
expect(result[:status]).to eq(:error)
expect(result[:locks]).to be_blank
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Lfs
class LockFileService < BaseService
def execute
unless can?(current_user, :push_code, project)
raise Gitlab::GitAccess::ForbiddenError, 'You have no permissions'
end
create_lock!
rescue ActiveRecord::RecordNotUnique
error('already locked', 409, current_lock)
rescue Gitlab::GitAccess::ForbiddenError => ex
error(ex.message, 403)
rescue StandardError => ex
error(ex.message, 500)
end
private
# rubocop: disable CodeReuse/ActiveRecord
def current_lock
project.lfs_file_locks.find_by(path: params[:path])
end
# rubocop: enable CodeReuse/ActiveRecord
def create_lock!
lock = project.lfs_file_locks.create!(user: current_user,
path: params[:path])
success(http_status: 201, lock: lock)
end
def error(message, http_status, lock = nil)
{
status: :error,
message: message,
http_status: http_status,
lock: lock
}
end
end
end
Lfs::LockFileService.prepend_mod_with('Lfs::LockFileService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Lfs::LockFileService, feature_category: :source_code_management do
let(:project) { create(:project) }
let(:current_user) { create(:user) }
subject { described_class.new(project, current_user, params) }
describe '#execute' do
let(:params) { { path: 'README.md' } }
context 'when not authorized' do
it "doesn't succeed" do
result = subject.execute
expect(result[:status]).to eq(:error)
expect(result[:http_status]).to eq(403)
expect(result[:message]).to eq('You have no permissions')
end
end
context 'when authorized' do
before do
project.add_developer(current_user)
end
context 'with an existent lock' do
let!(:lock) { create(:lfs_file_lock, project: project) }
it "doesn't succeed" do
expect(subject.execute[:status]).to eq(:error)
end
it "doesn't create the Lock" do
expect do
subject.execute
end.not_to change { LfsFileLock.count }
end
end
context 'without an existent lock' do
it "succeeds" do
expect(subject.execute[:status]).to eq(:success)
end
it "creates the Lock" do
expect do
subject.execute
end.to change { LfsFileLock.count }.by(1)
end
end
context 'when an error is raised' do
it "doesn't succeed" do
allow_next_instance_of(described_class) do |instance|
allow(instance).to receive(:create_lock!).and_raise(StandardError)
end
expect(subject.execute[:status]).to eq(:error)
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Keys
class LastUsedService
TIMEOUT = 1.day
attr_reader :key
# key - The Key for which to update the last used timestamp.
def initialize(key)
@key = key
end
def execute
return unless update?
# We _only_ want to update last_used_at and not also updated_at (which
# would be updated when using #touch).
key.update_column(:last_used_at, Time.zone.now)
end
def execute_async
return unless update?
::SshKeys::UpdateLastUsedAtWorker.perform_async(key.id)
end
def update?
return false if ::Gitlab::Database.read_only?
last_used = key.last_used_at
last_used.blank? || last_used <= TIMEOUT.ago
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Keys::LastUsedService, feature_category: :source_code_management do
describe '#execute', :clean_gitlab_redis_shared_state do
context 'when it has not been used recently' do
let(:key) { create(:key, last_used_at: 1.year.ago) }
let(:time) { Time.zone.now }
it 'updates the key' do
travel_to(time) { described_class.new(key).execute }
expect(key.reload.last_used_at).to be_like_time(time)
end
end
context 'when it has been used recently' do
let(:time) { 1.minute.ago }
let(:key) { create(:key, last_used_at: time) }
it 'does not update the key' do
described_class.new(key).execute
expect(key.reload.last_used_at).to be_like_time(time)
end
end
end
describe '#execute_async', :clean_gitlab_redis_shared_state do
context 'when it has not been used recently' do
let(:key) { create(:key, last_used_at: 1.year.ago) }
let(:time) { Time.zone.now }
it 'schedules a job to update last_used_at' do
expect(::SshKeys::UpdateLastUsedAtWorker).to receive(:perform_async)
travel_to(time) { described_class.new(key).execute_async }
end
end
context 'when it has been used recently' do
let(:key) { create(:key, last_used_at: 1.minute.ago) }
it 'does not schedule a job to update last_used_at' do
expect(::SshKeys::UpdateLastUsedAtWorker).not_to receive(:perform_async)
described_class.new(key).execute_async
end
end
end
describe '#update?', :clean_gitlab_redis_shared_state do
it 'returns true when no last used timestamp is present' do
key = build(:key, last_used_at: nil)
service = described_class.new(key)
expect(service.update?).to eq(true)
end
it 'returns true when the key needs to be updated' do
key = build(:key, last_used_at: 1.year.ago)
service = described_class.new(key)
expect(service.update?).to eq(true)
end
it 'returns false when the key does not yet need to be updated' do
key = build(:key, last_used_at: 1.minute.ago)
service = described_class.new(key)
expect(service.update?).to eq(false)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Keys
class ExpiryNotificationService < ::Keys::BaseService
attr_accessor :keys, :expiring_soon
def initialize(user, params)
@keys = params[:keys]
@expiring_soon = params[:expiring_soon]
super
end
def execute
return unless allowed?
if expiring_soon
trigger_expiring_soon_notification
else
trigger_expired_notification
end
end
private
def allowed?
user.can?(:receive_notifications)
end
def trigger_expiring_soon_notification
notification_service.ssh_key_expiring_soon(user, keys.map(&:fingerprint))
keys.update_all(before_expiry_notification_delivered_at: Time.current.utc)
end
def trigger_expired_notification
notification_service.ssh_key_expired(user, keys.map(&:fingerprint))
keys.update_all(expiry_notification_delivered_at: Time.current.utc)
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Keys::ExpiryNotificationService, feature_category: :source_code_management do
let_it_be_with_reload(:user) { create(:user) }
let(:params) { { keys: user.keys, expiring_soon: expiring_soon } }
subject { described_class.new(user, params) }
shared_examples 'sends a notification' do
it do
perform_enqueued_jobs do
subject.execute
end
should_email(user)
end
end
shared_examples 'uses notification service to send email to the user' do |notification_method|
it do
expect_next_instance_of(NotificationService) do |notification_service|
expect(notification_service).to receive(notification_method).with(key.user, [key.fingerprint])
end
subject.execute
end
end
shared_examples 'does not send notification' do
it do
perform_enqueued_jobs do
subject.execute
end
should_not_email(user)
end
end
shared_context 'block user' do
before do
user.block!
end
end
context 'with key expiring today', :mailer do
let_it_be_with_reload(:key) { create(:key, expires_at: 10.minutes.from_now, user: user) }
let(:expiring_soon) { false }
context 'when user has permission to receive notification' do
it_behaves_like 'sends a notification'
it_behaves_like 'uses notification service to send email to the user', :ssh_key_expired
it 'updates notified column' do
expect { subject.execute }.to change { key.reload.expiry_notification_delivered_at }
end
end
context 'when user does NOT have permission to receive notification' do
include_context 'block user'
it_behaves_like 'does not send notification'
it 'does not update notified column' do
expect { subject.execute }.not_to change { key.reload.expiry_notification_delivered_at }
end
end
end
context 'with key expiring soon', :mailer do
let_it_be_with_reload(:key) { create(:key, expires_at: 3.days.from_now, user: user) }
let(:expiring_soon) { true }
context 'when user has permission to receive notification' do
it_behaves_like 'sends a notification'
it_behaves_like 'uses notification service to send email to the user', :ssh_key_expiring_soon
it 'updates notified column' do
expect { subject.execute }.to change { key.reload.before_expiry_notification_delivered_at }
end
end
context 'when user does NOT have permission to receive notification' do
include_context 'block user'
it_behaves_like 'does not send notification'
it 'does not update notified column' do
expect { subject.execute }.not_to change { key.reload.before_expiry_notification_delivered_at }
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Keys
class RevokeService < ::Keys::DestroyService
def execute(key)
key.transaction do
unverify_associated_signatures(key)
raise ActiveRecord::Rollback unless super(key)
end
end
private
def unverify_associated_signatures(key)
key.ssh_signatures.each_batch do |batch|
batch.update_all(
verification_status: CommitSignatures::SshSignature.verification_statuses[:revoked_key],
updated_at: Time.zone.now
)
end
end
end
end
Keys::DestroyService.prepend_mod
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Keys::RevokeService, feature_category: :source_code_management do
let(:user) { create(:user) }
subject(:service) { described_class.new(user) }
it 'destroys a key' do
key = create(:key)
expect { service.execute(key) }.to change { key.persisted? }.from(true).to(false)
end
it 'unverifies associated signatures' do
key = create(:key)
signature = create(:ssh_signature, key: key)
expect do
service.execute(key)
end.to change { signature.reload.key }.from(key).to(nil)
.and change { signature.reload.verification_status }.from('verified').to('revoked_key')
end
it 'does not unverifies signatures if destroy fails' do
key = create(:key)
signature = create(:ssh_signature, key: key)
expect(key).to receive(:destroy).and_return(false)
expect { service.execute(key) }.not_to change { signature.reload.verification_status }
expect(key).to be_persisted
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Keys
class DestroyService < ::Keys::BaseService
def execute(key)
return unless destroy_possible?(key)
destroy(key)
end
private
# overridden in EE::Keys::DestroyService
def destroy_possible?(key)
true
end
def destroy(key)
key.destroy
end
end
end
Keys::DestroyService.prepend_mod
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Keys::DestroyService, feature_category: :source_code_management do
let(:user) { create(:user) }
subject { described_class.new(user) }
it 'destroys a key' do
key = create(:personal_key)
expect { subject.execute(key) }.to change(Key, :count).by(-1)
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Keys
class CreateService < ::Keys::BaseService
attr_accessor :current_user
def initialize(current_user, params = {})
@current_user = current_user
@params = params
@ip_address = @params.delete(:ip_address)
@user = params.delete(:user) || current_user
end
def execute
key = user.keys.create(params)
notification_service.new_key(key) if key.persisted?
key
end
end
end
Keys::CreateService.prepend_mod_with('Keys::CreateService')
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Keys::CreateService, feature_category: :source_code_management do
let(:user) { create(:user) }
let(:params) { attributes_for(:key) }
subject { described_class.new(user, params) }
context 'notification', :mailer do
it 'sends a notification' do
perform_enqueued_jobs do
subject.execute
end
should_email(user)
end
end
it 'creates a key' do
expect { subject.execute }.to change { user.keys.where(params).count }.by(1)
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
class InviteMemberBuilder < StandardMemberBuilder
def execute
if user_by_email
find_or_initialize_member_by_user(user_by_email.id)
else
source.members_and_requesters.find_or_initialize_by(invite_email: invitee) # rubocop:disable CodeReuse/ActiveRecord
end
end
private
def user_by_email
source.users_by_emails([invitee])[invitee]
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::InviteMemberBuilder, feature_category: :groups_and_projects do
let_it_be(:source) { create(:group) }
let_it_be(:existing_member) { create(:group_member) }
let(:existing_members) { { existing_member.user.id => existing_member } }
describe '#execute' do
context 'when user record found by email' do
it 'returns member from existing members hash' do
expect(described_class.new(source, existing_member.user.email, existing_members).execute).to eq existing_member
end
it 'builds a new member' do
user = create(:user)
member = described_class.new(source, user.email, existing_members).execute
expect(member).to be_new_record
expect(member.user).to eq user
end
end
end
context 'when no existing users found by the email' do
it 'finds existing member' do
member = create(:group_member, :invited, source: source)
expect(described_class.new(source, member.invite_email, existing_members).execute).to eq member
end
it 'builds a new member' do
email = '[email protected]'
member = described_class.new(source, email, existing_members).execute
expect(member).to be_new_record
expect(member.invite_email).to eq email
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
class InvitationReminderEmailService
include Gitlab::Utils::StrongMemoize
attr_reader :invitation
MAX_INVITATION_LIFESPAN = 14.0
REMINDER_RATIO = [2, 5, 10].freeze
def initialize(invitation)
@invitation = invitation
end
def execute
reminder_index = days_on_which_to_send_reminders.index(days_after_invitation_sent)
return unless reminder_index
invitation.send_invitation_reminder(reminder_index)
end
private
def days_after_invitation_sent
(Date.today - invitation.created_at.to_date).to_i
end
def days_on_which_to_send_reminders
# Don't send any reminders if the invitation has expired or expires today
return [] if invitation.expires_at && invitation.expires_at <= Date.today
# Calculate the number of days on which to send reminders based on the MAX_INVITATION_LIFESPAN and the REMINDER_RATIO
REMINDER_RATIO.map { |number_of_days| ((number_of_days * invitation_lifespan_in_days) / MAX_INVITATION_LIFESPAN).ceil }.uniq
end
def invitation_lifespan_in_days
# When the invitation lifespan is more than 14 days or does not expire, send the reminders within 14 days
strong_memoize(:invitation_lifespan_in_days) do
if invitation.expires_at
[(invitation.expires_at - invitation.created_at.to_date).to_i, MAX_INVITATION_LIFESPAN].min
else
MAX_INVITATION_LIFESPAN
end
end
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::InvitationReminderEmailService, feature_category: :groups_and_projects do
describe 'sending invitation reminders' do
subject { described_class.new(invitation).execute }
let_it_be(:frozen_time) { Date.today.beginning_of_day }
let_it_be(:invitation) { build(:group_member, :invited, created_at: frozen_time) }
before do
invitation.expires_at = frozen_time + expires_at_days.days if expires_at_days
end
using RSpec::Parameterized::TableSyntax
where(:expires_at_days, :send_reminder_at_days) do
0 | []
1 | []
2 | [1]
3 | [1, 2]
4 | [1, 2, 3]
5 | [1, 2, 4]
6 | [1, 3, 5]
7 | [1, 3, 5]
8 | [2, 3, 6]
9 | [2, 4, 7]
10 | [2, 4, 8]
11 | [2, 4, 8]
12 | [2, 5, 9]
13 | [2, 5, 10]
14 | [2, 5, 10]
15 | [2, 5, 10]
nil | [2, 5, 10]
end
with_them do
# Create an invitation today with an expiration date from 0 to 10 days in the future or without an expiration date
# We chose 10 days here, because we fetch invitations that were created at most 10 days ago.
11.times do |day|
it 'sends an invitation reminder only on the expected days' do
next if day > (expires_at_days || 10) # We don't need to test after the invitation has already expired
# We are traveling in a loop from today to 10 days from now
travel_to(frozen_time + day.days) do
# Given an expiration date and the number of days after the creation of the invitation based on the current day in the loop, a reminder may be sent
if (reminder_index = send_reminder_at_days.index(day))
expect(invitation).to receive(:send_invitation_reminder).with(reminder_index)
else
expect(invitation).not_to receive(:send_invitation_reminder)
end
subject
end
end
end
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
class BaseService < ::BaseService
# current_user - The user that performs the action
# params - A hash of parameters
def initialize(current_user = nil, params = {})
@current_user = current_user
@params = params
# could be a string, force to an integer, part of fix
# https://gitlab.com/gitlab-org/gitlab/-/issues/219496
# Allow the ArgumentError to be raised if it can't be converted to an integer.
@params[:access_level] = Integer(@params[:access_level]) if @params[:access_level]
end
def after_execute(args)
# overridden in EE::Members modules
end
private
def update_member_permission(member)
case member
when GroupMember
:update_group_member
when ProjectMember
:update_project_member
else
raise "Unknown member type: #{member}!"
end
end
def override_member_permission(member)
case member
when GroupMember
:override_group_member
when ProjectMember
:override_project_member
else
raise "Unknown member type: #{member}!"
end
end
def action_member_permission(action, member)
case action
when :update
update_member_permission(member)
when :override
override_member_permission(member)
else
raise "Unknown action '#{action}' on #{member}!"
end
end
def resolve_access_request_todos(member)
todo_service.resolve_access_request_todos(member)
end
def enqueue_delete_todos(member)
type = member.is_a?(GroupMember) ? 'Group' : 'Project'
# don't enqueue immediately to prevent todos removal in case of a mistake
member.run_after_commit_or_now do
TodosDestroyer::EntityLeaveWorker.perform_in(Todo::WAIT_FOR_DELETE, member.user_id, member.source_id, type)
end
end
def cannot_assign_owner_responsibilities_to_member_in_project?(member)
# The purpose of this check is -
# We can have direct members who are "Owners" in a project going forward and
# we do not want Maintainers of the project updating/adding/removing other "Owners"
# within the project.
# Only OWNERs in a project should be able to manage any action around OWNERship in that project.
member.is_a?(ProjectMember) &&
!can?(current_user, :manage_owners, member.source)
end
alias_method :cannot_revoke_owner_responsibilities_from_member_in_project?,
:cannot_assign_owner_responsibilities_to_member_in_project?
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::BaseService, feature_category: :groups_and_projects do
let_it_be(:access_requester) { create(:group_member) }
describe '#resolve_access_request_todos' do
it 'calls the resolve_access_request_todos of todo service' do
expect_next_instance_of(TodoService) do |todo_service|
expect(todo_service)
.to receive(:resolve_access_request_todos).with(access_requester)
end
described_class.new.send(:resolve_access_request_todos, access_requester)
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
class UnassignIssuablesService
attr_reader :user, :entity
def initialize(user, entity)
@user = user
@entity = entity
end
def execute
return unless entity && user
project_ids = entity.is_a?(Group) ? entity.all_projects.select(:id) : [entity.id]
user.issue_assignees.on_issues(Issue.in_projects(project_ids).select(:id)).delete_all
user.merge_request_assignees.in_projects(project_ids).delete_all
user.invalidate_cache_counts
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::UnassignIssuablesService, feature_category: :groups_and_projects do
let_it_be(:group) { create(:group, :private) }
let_it_be(:project) { create(:project, group: group) }
let_it_be(:user, reload: true) { create(:user) }
let_it_be(:assigned_issue1, reload: true) { create(:issue, project: project, assignees: [user]) }
let_it_be(:assigned_issue2, reload: true) { create(:issue, project: project, assignees: [user]) }
let!(:assigned_merge_request1) { create(:merge_request, :simple, :closed, target_project: project, source_project: project, assignees: [user], title: 'Test1') }
let!(:assigned_merge_request2) { create(:merge_request, :simple, :opened, target_project: project, source_project: project, assignees: [user], title: 'Test2') }
describe '#execute' do
RSpec.shared_examples 'un-assigning issuables' do |issue_count, mr_count, open_issue_count, open_mr_count|
it 'removes issuable assignments', :aggregate_failures do
expect(user.assigned_issues.count).to eq(issue_count)
expect(user.assigned_merge_requests.count).to eq(mr_count)
subject
expect(user.assigned_issues.count).to eq(0)
expect(user.assigned_merge_requests.count).to eq(0)
end
it 'invalidates user cache', :aggregate_failures, :clean_gitlab_redis_cache do
expect(user.assigned_open_merge_requests_count).to eq(open_mr_count)
expect(user.assigned_open_issues_count).to eq(open_issue_count)
subject
expect(user.assigned_open_merge_requests_count).to eq(0)
expect(user.assigned_open_issues_count).to eq(0)
end
end
context 'when a user leaves a project' do
before do
project.add_maintainer(user)
end
subject { described_class.new(user, project).execute }
it_behaves_like 'un-assigning issuables', 2, 2, 2, 1
end
context 'when a user leaves a group' do
let_it_be(:project2) { create(:project, group: group) }
let_it_be(:assigned_issue3, reload: true) { create(:issue, project: project2, assignees: [user]) }
let_it_be(:assigned_issue4, reload: true) { create(:issue, project: project2, assignees: [user]) }
let!(:assigned_merge_request3) { create(:merge_request, :simple, :closed, target_project: project2, source_project: project2, assignees: [user], title: 'Test1') }
let!(:assigned_merge_request4) { create(:merge_request, :simple, :opened, target_project: project2, source_project: project2, assignees: [user], title: 'Test2') }
before do
group.add_maintainer(user)
end
subject { described_class.new(user, group).execute }
it_behaves_like 'un-assigning issuables', 4, 4, 4, 2
end
end
end
|
Write RSpec test file for following ruby class
```ruby
# frozen_string_literal: true
module Members
class StandardMemberBuilder
def initialize(source, invitee, existing_members)
@source = source
@invitee = invitee
@existing_members = existing_members
end
def execute
find_or_initialize_member_by_user(invitee.id)
end
private
attr_reader :source, :invitee, :existing_members
def find_or_initialize_member_by_user(user_id)
existing_members[user_id] || source.members_and_requesters.build(user_id: user_id) # rubocop:disable CodeReuse/ActiveRecord
end
end
end
``` | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe Members::StandardMemberBuilder, feature_category: :groups_and_projects do
let_it_be(:source) { create(:group) }
let_it_be(:existing_member) { create(:group_member) }
let(:existing_members) { { existing_member.user.id => existing_member } }
describe '#execute' do
it 'returns member from existing members hash' do
expect(described_class.new(source, existing_member.user, existing_members).execute).to eq existing_member
end
it 'builds a new member' do
user = create(:user)
member = described_class.new(source, user, existing_members).execute
expect(member).to be_new_record
expect(member.user).to eq user
end
end
end
|