From a09983ae35713f5a2bbb100981116d31ce99826e Mon Sep 17 00:00:00 2001 From: GitLab Bot Date: Mon, 20 Jul 2020 12:26:25 +0000 Subject: Add latest changes from gitlab-org/gitlab@13-2-stable-ee --- .../packages/conan/package_file_finder_spec.rb | 64 +++++++++ spec/finders/packages/conan/package_finder_spec.rb | 22 +++ spec/finders/packages/go/module_finder_spec.rb | 71 +++++++++ spec/finders/packages/go/version_finder_spec.rb | 160 +++++++++++++++++++++ .../finders/packages/group_packages_finder_spec.rb | 156 ++++++++++++++++++++ spec/finders/packages/maven/package_finder_spec.rb | 57 ++++++++ spec/finders/packages/npm/package_finder_spec.rb | 34 +++++ spec/finders/packages/nuget/package_finder_spec.rb | 75 ++++++++++ spec/finders/packages/package_file_finder_spec.rb | 44 ++++++ spec/finders/packages/package_finder_spec.rb | 25 ++++ spec/finders/packages/packages_finder_spec.rb | 90 ++++++++++++ spec/finders/packages/tags_finder_spec.rb | 68 +++++++++ 12 files changed, 866 insertions(+) create mode 100644 spec/finders/packages/conan/package_file_finder_spec.rb create mode 100644 spec/finders/packages/conan/package_finder_spec.rb create mode 100644 spec/finders/packages/go/module_finder_spec.rb create mode 100644 spec/finders/packages/go/version_finder_spec.rb create mode 100644 spec/finders/packages/group_packages_finder_spec.rb create mode 100644 spec/finders/packages/maven/package_finder_spec.rb create mode 100644 spec/finders/packages/npm/package_finder_spec.rb create mode 100644 spec/finders/packages/nuget/package_finder_spec.rb create mode 100644 spec/finders/packages/package_file_finder_spec.rb create mode 100644 spec/finders/packages/package_finder_spec.rb create mode 100644 spec/finders/packages/packages_finder_spec.rb create mode 100644 spec/finders/packages/tags_finder_spec.rb (limited to 'spec/finders/packages') diff --git a/spec/finders/packages/conan/package_file_finder_spec.rb b/spec/finders/packages/conan/package_file_finder_spec.rb new file mode 100644 index 00000000000..d0c9efa1418 --- /dev/null +++ b/spec/finders/packages/conan/package_file_finder_spec.rb @@ -0,0 +1,64 @@ +# frozen_string_literal: true +require 'spec_helper' + +RSpec.describe ::Packages::Conan::PackageFileFinder do + let_it_be(:package) { create(:conan_package) } + let_it_be(:package_file) { package.package_files.first } + let(:package_file_name) { package_file.file_name } + let(:params) { {} } + + RSpec.shared_examples 'package file finder examples' do + it { is_expected.to eq(package_file) } + + context 'with conan_file_type' do + # conan packages contain a conanmanifest.txt file for both conan_file_types + let(:package_file_name) { 'conanmanifest.txt' } + let(:params) { { conan_file_type: :recipe_file } } + + it { expect(subject.conan_file_type).to eq('recipe_file') } + end + + context 'with conan_package_reference' do + let_it_be(:other_package) { create(:conan_package) } + let_it_be(:package_file_name) { 'conan_package.tgz' } + let_it_be(:package_file) { package.package_files.find_by(file_name: package_file_name) } + + let(:params) do + { conan_package_reference: package_file.conan_file_metadatum.conan_package_reference } + end + + it { expect(subject).to eq(package_file) } + end + + context 'with file_name_like' do + let(:package_file_name) { package_file.file_name.upcase } + let(:params) { { with_file_name_like: true } } + + it { is_expected.to eq(package_file) } + end + end + + describe '#execute' do + subject { described_class.new(package, package_file_name, params).execute } + + it_behaves_like 'package file finder examples' + + context 'with unknown file_name' do + let(:package_file_name) { 'unknown.jpg' } + + it { expect(subject).to be_nil } + end + end + + describe '#execute!' do + subject { described_class.new(package, package_file_name, params).execute! } + + it_behaves_like 'package file finder examples' + + context 'with unknown file_name' do + let(:package_file_name) { 'unknown.jpg' } + + it { expect { subject }.to raise_error(ActiveRecord::RecordNotFound) } + end + end +end diff --git a/spec/finders/packages/conan/package_finder_spec.rb b/spec/finders/packages/conan/package_finder_spec.rb new file mode 100644 index 00000000000..936a0e5ff4b --- /dev/null +++ b/spec/finders/packages/conan/package_finder_spec.rb @@ -0,0 +1,22 @@ +# frozen_string_literal: true +require 'spec_helper' + +RSpec.describe ::Packages::Conan::PackageFinder do + let_it_be(:user) { create(:user) } + let_it_be(:project) { create(:project, :public) } + + describe '#execute' do + let!(:conan_package) { create(:conan_package, project: project) } + let!(:conan_package2) { create(:conan_package, project: project) } + + subject { described_class.new(user, query: query).execute } + + context 'packages that are not visible to user' do + let!(:non_visible_project) { create(:project, :private) } + let!(:non_visible_conan_package) { create(:conan_package, project: non_visible_project) } + let(:query) { "#{conan_package.name.split('/').first[0, 3]}%" } + + it { is_expected.to eq [conan_package, conan_package2] } + end + end +end diff --git a/spec/finders/packages/go/module_finder_spec.rb b/spec/finders/packages/go/module_finder_spec.rb new file mode 100644 index 00000000000..e5c8827fc8d --- /dev/null +++ b/spec/finders/packages/go/module_finder_spec.rb @@ -0,0 +1,71 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Packages::Go::ModuleFinder do + let_it_be(:project) { create :project } + let_it_be(:other_project) { create :project } + let(:finder) { described_class.new project, module_name } + + shared_examples 'an invalid path' do + describe '#module_name' do + it 'returns the expected name' do + expect(finder.module_name).to eq(expected_name) + end + end + + describe '#execute' do + it 'returns nil' do + expect(finder.execute).to be_nil + end + end + end + + describe '#execute' do + context 'with module name equal to project name' do + let(:module_name) { base_url(project) } + + it 'returns a module with empty path' do + mod = finder.execute + expect(mod).not_to be_nil + expect(mod.path).to eq('') + end + end + + context 'with module name starting with project name and slash' do + let(:module_name) { base_url(project) + '/mod' } + + it 'returns a module with non-empty path' do + mod = finder.execute + expect(mod).not_to be_nil + expect(mod.path).to eq('mod') + end + end + + context 'with a module name not equal to and not starting with project name' do + let(:module_name) { base_url(other_project) } + + it 'returns nil' do + expect(finder.execute).to be_nil + end + end + end + + context 'with relative path component' do + it_behaves_like 'an invalid path' do + let(:module_name) { base_url(project) + '/../xyz' } + let(:expected_name) { base_url(project.namespace) + '/xyz' } + end + end + + context 'with many relative path components' do + it_behaves_like 'an invalid path' do + let(:module_name) { base_url(project) + ('/..' * 10) + '/xyz' } + let(:expected_name) { ('../' * 7) + 'xyz' } + end + end + + def base_url(project) + "#{Settings.build_gitlab_go_url}/#{project.full_path}" + end +end diff --git a/spec/finders/packages/go/version_finder_spec.rb b/spec/finders/packages/go/version_finder_spec.rb new file mode 100644 index 00000000000..b67842d1e05 --- /dev/null +++ b/spec/finders/packages/go/version_finder_spec.rb @@ -0,0 +1,160 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe Packages::Go::VersionFinder do + let_it_be(:user) { create :user } + let_it_be(:project) { create :project_empty_repo, creator: user, path: 'my-go-lib' } + + let(:finder) { described_class.new mod } + + before :all do + create :go_module_commit, :files, project: project, tag: 'v1.0.0', files: { 'README.md' => 'Hi' } + create :go_module_commit, :module, project: project, tag: 'v1.0.1' + create :go_module_commit, :package, project: project, tag: 'v1.0.2', path: 'pkg' + create :go_module_commit, :module, project: project, tag: 'v1.0.3', name: 'mod' + create :go_module_commit, :module, project: project, tag: 'v1.0.4', name: 'bad-mod', url: 'example.com/go-lib' + create :go_module_commit, :files, project: project, tag: 'c1', files: { 'y.go' => "package a\n" } + create :go_module_commit, :module, project: project, tag: 'c2', name: 'v2' + create :go_module_commit, :files, project: project, tag: 'v2.0.0', files: { 'v2/x.go' => "package a\n" } + end + + before do + stub_feature_flags(go_proxy_disable_gomod_validation: false) + end + + shared_examples '#execute' do |*expected| + it "returns #{expected.empty? ? 'nothing' : expected.join(', ')}" do + actual = finder.execute.map { |x| x.name } + expect(actual.to_set).to eq(expected.to_set) + end + end + + shared_examples '#find with an invalid argument' do |message| + it "raises an argument exception: #{message}" do + expect { finder.find(target) }.to raise_error(ArgumentError, message) + end + end + + describe '#execute' do + context 'for the root module' do + let(:mod) { create :go_module, project: project } + + it_behaves_like '#execute', 'v1.0.1', 'v1.0.2', 'v1.0.3', 'v1.0.4' + end + + context 'for the package' do + let(:mod) { create :go_module, project: project, path: 'pkg' } + + it_behaves_like '#execute' + end + + context 'for the submodule' do + let(:mod) { create :go_module, project: project, path: 'mod' } + + it_behaves_like '#execute', 'v1.0.3', 'v1.0.4' + end + + context 'for the root module v2' do + let(:mod) { create :go_module, project: project, path: 'v2' } + + it_behaves_like '#execute', 'v2.0.0' + end + + context 'for the bad module' do + let(:mod) { create :go_module, project: project, path: 'bad-mod' } + + context 'with gomod checking enabled' do + it_behaves_like '#execute' + end + + context 'with gomod checking disabled' do + before do + stub_feature_flags(go_proxy_disable_gomod_validation: true) + end + + it_behaves_like '#execute', 'v1.0.4' + end + end + end + + describe '#find' do + let(:mod) { create :go_module, project: project } + + context 'with a ref' do + it 'returns a ref version' do + ref = project.repository.find_branch 'master' + v = finder.find(ref) + expect(v.type).to eq(:ref) + expect(v.ref).to eq(ref) + end + end + + context 'with a semver tag' do + it 'returns a version with a semver' do + v = finder.find(project.repository.find_tag('v1.0.0')) + expect(v.major).to eq(1) + expect(v.minor).to eq(0) + expect(v.patch).to eq(0) + expect(v.prerelease).to be_nil + expect(v.build).to be_nil + end + end + + context 'with a semver tag string' do + it 'returns a version with a semver' do + v = finder.find('v1.0.1') + expect(v.major).to eq(1) + expect(v.minor).to eq(0) + expect(v.patch).to eq(1) + expect(v.prerelease).to be_nil + expect(v.build).to be_nil + end + end + + context 'with a commit' do + it 'retruns a commit version' do + v = finder.find(project.repository.head_commit) + expect(v.type).to eq(:commit) + end + end + + context 'with a pseudo-version' do + it 'returns a pseudo version' do + commit = project.repository.head_commit + pseudo = "v0.0.0-#{commit.committed_date.strftime('%Y%m%d%H%M%S')}-#{commit.sha[0..11]}" + v = finder.find(pseudo) + expect(v.type).to eq(:pseudo) + expect(v.commit).to eq(commit) + expect(v.name).to eq(pseudo) + end + end + + context 'with a string that is not a semantic version' do + it 'returns nil' do + expect(finder.find('not-a-semver')).to be_nil + end + end + + context 'with a pseudo-version that does not reference a commit' do + it_behaves_like '#find with an invalid argument', 'invalid pseudo-version: unknown commit' do + let(:commit) { project.repository.head_commit } + let(:target) { "v0.0.0-#{commit.committed_date.strftime('%Y%m%d%H%M%S')}-#{'0' * 12}" } + end + end + + context 'with a pseudo-version with a short sha' do + it_behaves_like '#find with an invalid argument', 'invalid pseudo-version: revision is shorter than canonical' do + let(:commit) { project.repository.head_commit } + let(:target) { "v0.0.0-#{commit.committed_date.strftime('%Y%m%d%H%M%S')}-#{commit.sha[0..10]}" } + end + end + + context 'with a pseudo-version with an invalid timestamp' do + it_behaves_like '#find with an invalid argument', 'invalid pseudo-version: does not match version-control timestamp' do + let(:commit) { project.repository.head_commit } + let(:target) { "v0.0.0-#{'0' * 14}-#{commit.sha[0..11]}" } + end + end + end +end diff --git a/spec/finders/packages/group_packages_finder_spec.rb b/spec/finders/packages/group_packages_finder_spec.rb new file mode 100644 index 00000000000..163c920f621 --- /dev/null +++ b/spec/finders/packages/group_packages_finder_spec.rb @@ -0,0 +1,156 @@ +# frozen_string_literal: true +require 'spec_helper' + +RSpec.describe Packages::GroupPackagesFinder do + let_it_be(:user) { create(:user) } + let_it_be(:group) { create(:group) } + let_it_be(:project) { create(:project, namespace: group) } + let(:another_group) { create(:group) } + + before do + group.add_developer(user) + end + + describe '#execute' do + let(:params) { { exclude_subgroups: false } } + + subject { described_class.new(user, group, params).execute } + + shared_examples 'with package type' do |package_type| + let(:params) { { exclude_subgroups: false, package_type: package_type } } + + it { is_expected.to match_array([send("package_#{package_type}")]) } + end + + def self.package_types + @package_types ||= Packages::Package.package_types.keys + end + + context 'group has packages' do + let!(:package1) { create(:maven_package, project: project) } + let!(:package2) { create(:maven_package, project: project) } + let!(:package3) { create(:maven_package) } + + it { is_expected.to match_array([package1, package2]) } + + context 'subgroup has packages' do + let(:subgroup) { create(:group, parent: group) } + let(:subproject) { create(:project, namespace: subgroup) } + let!(:package4) { create(:npm_package, project: subproject) } + + it { is_expected.to match_array([package1, package2, package4]) } + + context 'excluding subgroups' do + let(:params) { { exclude_subgroups: true } } + + it { is_expected.to match_array([package1, package2]) } + end + end + + context 'when there are processing packages' do + let!(:package4) { create(:nuget_package, project: project, name: Packages::Nuget::CreatePackageService::TEMPORARY_PACKAGE_NAME) } + + it { is_expected.to match_array([package1, package2]) } + end + + context 'does not include packages without version number' do + let!(:package_without_version) { create(:maven_package, project: project, version: nil) } + + it { is_expected.not_to include(package_without_version) } + end + + context 'with package_name' do + let_it_be(:named_package) { create(:maven_package, project: project, name: 'maven') } + let(:params) { { package_name: package_name } } + + context 'as complete name' do + let(:package_name) { 'maven' } + + it { is_expected.to eq([named_package]) } + end + + %w[aven mav ave].each do |filter| + context "for fuzzy filter #{filter}" do + let(:package_name) { filter } + + it { is_expected.to eq([named_package]) } + end + end + end + end + + context 'group has package of all types' do + package_types.each { |pt| let!("package_#{pt}") { create("#{pt}_package", project: project) } } + + package_types.each do |package_type| + it_behaves_like 'with package type', package_type + end + end + + context 'group has no packages' do + it { is_expected.to be_empty } + end + + context 'group is nil' do + subject { described_class.new(user, nil).execute } + + it { is_expected.to be_empty} + end + + context 'package type is nil' do + let!(:package1) { create(:maven_package, project: project) } + + subject { described_class.new(user, group, package_type: nil).execute } + + it { is_expected.to match_array([package1])} + end + + context 'with invalid package_type' do + let(:params) { { package_type: 'invalid_type' } } + + it { expect { subject }.to raise_exception(described_class::InvalidPackageTypeError) } + end + + context 'when project is public' do + let_it_be(:other_user) { create(:user) } + let(:finder) { described_class.new(other_user, group) } + + before do + project.update!(visibility_level: ProjectFeature::ENABLED) + end + + context 'when packages are public' do + before do + project.project_feature.update!( + builds_access_level: ProjectFeature::PRIVATE, + merge_requests_access_level: ProjectFeature::PRIVATE, + repository_access_level: ProjectFeature::ENABLED) + end + + it 'returns group packages' do + package1 = create(:maven_package, project: project) + package2 = create(:maven_package, project: project) + create(:maven_package) + + expect(finder.execute).to match_array([package1, package2]) + end + end + + context 'packages are members only' do + before do + project.project_feature.update!( + builds_access_level: ProjectFeature::PRIVATE, + merge_requests_access_level: ProjectFeature::PRIVATE, + repository_access_level: ProjectFeature::PRIVATE) + + create(:maven_package, project: project) + create(:maven_package) + end + + it 'filters out the project if the user doesn\'t have permission' do + expect(finder.execute).to be_empty + end + end + end + end +end diff --git a/spec/finders/packages/maven/package_finder_spec.rb b/spec/finders/packages/maven/package_finder_spec.rb new file mode 100644 index 00000000000..239e8c10f52 --- /dev/null +++ b/spec/finders/packages/maven/package_finder_spec.rb @@ -0,0 +1,57 @@ +# frozen_string_literal: true +require 'spec_helper' + +RSpec.describe ::Packages::Maven::PackageFinder do + let(:user) { create(:user) } + let(:group) { create(:group) } + let(:project) { create(:project, namespace: group) } + let(:package) { create(:maven_package, project: project) } + + before do + group.add_developer(user) + end + + describe '#execute!' do + context 'within the project' do + it 'returns a package' do + finder = described_class.new(package.maven_metadatum.path, user, project: project) + + expect(finder.execute!).to eq(package) + end + + it 'raises an error' do + finder = described_class.new('com/example/my-app/1.0-SNAPSHOT', user, project: project) + + expect { finder.execute! }.to raise_error(ActiveRecord::RecordNotFound) + end + end + + context 'across all projects' do + it 'returns a package' do + finder = described_class.new(package.maven_metadatum.path, user) + + expect(finder.execute!).to eq(package) + end + + it 'raises an error' do + finder = described_class.new('com/example/my-app/1.0-SNAPSHOT', user) + + expect { finder.execute! }.to raise_error(ActiveRecord::RecordNotFound) + end + end + + context 'within a group' do + it 'returns a package' do + finder = described_class.new(package.maven_metadatum.path, user, group: group) + + expect(finder.execute!).to eq(package) + end + + it 'raises an error' do + finder = described_class.new('com/example/my-app/1.0-SNAPSHOT', user, group: group) + + expect { finder.execute! }.to raise_error(ActiveRecord::RecordNotFound) + end + end + end +end diff --git a/spec/finders/packages/npm/package_finder_spec.rb b/spec/finders/packages/npm/package_finder_spec.rb new file mode 100644 index 00000000000..be54b1f8b18 --- /dev/null +++ b/spec/finders/packages/npm/package_finder_spec.rb @@ -0,0 +1,34 @@ +# frozen_string_literal: true +require 'spec_helper' + +RSpec.describe ::Packages::Npm::PackageFinder do + let(:package) { create(:npm_package) } + let(:project) { package.project } + let(:package_name) { package.name } + + describe '#execute!' do + subject { described_class.new(project, package_name).execute } + + it { is_expected.to eq([package]) } + + context 'with unknown package name' do + let(:package_name) { 'baz' } + + it { is_expected.to be_empty } + end + end + + describe '#find_by_version' do + let(:version) { package.version } + + subject { described_class.new(project, package.name).find_by_version(version) } + + it { is_expected.to eq(package) } + + context 'with unknown version' do + let(:version) { 'foobar' } + + it { is_expected.to be_nil } + end + end +end diff --git a/spec/finders/packages/nuget/package_finder_spec.rb b/spec/finders/packages/nuget/package_finder_spec.rb new file mode 100644 index 00000000000..9295d0c7a2f --- /dev/null +++ b/spec/finders/packages/nuget/package_finder_spec.rb @@ -0,0 +1,75 @@ +# frozen_string_literal: true +require 'spec_helper' + +RSpec.describe Packages::Nuget::PackageFinder do + let_it_be(:package1) { create(:nuget_package) } + let_it_be(:project) { package1.project } + let_it_be(:package2) { create(:nuget_package, name: package1.name, version: '2.0.0', project: project) } + let_it_be(:package3) { create(:nuget_package, name: 'Another.Dummy.Package', project: project) } + let(:package_name) { package1.name } + let(:package_version) { nil } + let(:limit) { 50 } + + describe '#execute!' do + subject { described_class.new(project, package_name: package_name, package_version: package_version, limit: limit).execute } + + it { is_expected.to match_array([package1, package2]) } + + context 'with lower case package name' do + let(:package_name) { package1.name.downcase } + + it { is_expected.to match_array([package1, package2]) } + end + + context 'with unknown package name' do + let(:package_name) { 'foobar' } + + it { is_expected.to be_empty } + end + + context 'with valid version' do + let(:package_version) { '2.0.0' } + + it { is_expected.to match_array([package2]) } + end + + context 'with unknown version' do + let(:package_version) { 'foobar' } + + it { is_expected.to be_empty } + end + + context 'with limit hit' do + let_it_be(:package4) { create(:nuget_package, name: package1.name, project: project) } + let_it_be(:package5) { create(:nuget_package, name: package1.name, project: project) } + let_it_be(:package6) { create(:nuget_package, name: package1.name, project: project) } + let(:limit) { 2 } + + it { is_expected.to match_array([package5, package6]) } + end + + context 'with downcase package name' do + let(:package_name) { package1.name.downcase } + + it { is_expected.to match_array([package1, package2]) } + end + + context 'with prefix wildcard' do + let(:package_name) { "%#{package1.name[3..-1]}" } + + it { is_expected.to match_array([package1, package2]) } + end + + context 'with suffix wildcard' do + let(:package_name) { "#{package1.name[0..-3]}%" } + + it { is_expected.to match_array([package1, package2]) } + end + + context 'with surrounding wildcards' do + let(:package_name) { "%#{package1.name[3..-3]}%" } + + it { is_expected.to match_array([package1, package2]) } + end + end +end diff --git a/spec/finders/packages/package_file_finder_spec.rb b/spec/finders/packages/package_file_finder_spec.rb new file mode 100644 index 00000000000..ab58f75fcae --- /dev/null +++ b/spec/finders/packages/package_file_finder_spec.rb @@ -0,0 +1,44 @@ +# frozen_string_literal: true +require 'spec_helper' + +RSpec.describe Packages::PackageFileFinder do + let_it_be(:package) { create(:maven_package) } + let_it_be(:package_file) { package.package_files.first } + let(:package_file_name) { package_file.file_name } + let(:params) { {} } + + RSpec.shared_examples 'package file finder examples' do + it { is_expected.to eq(package_file) } + + context 'with file_name_like' do + let(:package_file_name) { package_file.file_name.upcase } + let(:params) { { with_file_name_like: true } } + + it { is_expected.to eq(package_file) } + end + end + + describe '#execute' do + subject { described_class.new(package, package_file_name, params).execute } + + it_behaves_like 'package file finder examples' + + context 'with unknown file_name' do + let(:package_file_name) { 'unknown.jpg' } + + it { expect(subject).to be_nil } + end + end + + describe '#execute!' do + subject { described_class.new(package, package_file_name, params).execute! } + + it_behaves_like 'package file finder examples' + + context 'with unknown file_name' do + let(:package_file_name) { 'unknown.jpg' } + + it { expect { subject }.to raise_error(ActiveRecord::RecordNotFound) } + end + end +end diff --git a/spec/finders/packages/package_finder_spec.rb b/spec/finders/packages/package_finder_spec.rb new file mode 100644 index 00000000000..ef07e7575d1 --- /dev/null +++ b/spec/finders/packages/package_finder_spec.rb @@ -0,0 +1,25 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe ::Packages::PackageFinder do + let_it_be(:project) { create(:project) } + let_it_be(:maven_package) { create(:maven_package, project: project) } + + describe '#execute' do + let(:package_id) { maven_package.id } + + subject { described_class.new(project, package_id).execute } + + it { is_expected.to eq(maven_package) } + + context 'processing packages' do + let_it_be(:nuget_package) { create(:nuget_package, project: project, name: Packages::Nuget::CreatePackageService::TEMPORARY_PACKAGE_NAME) } + let(:package_id) { nuget_package.id } + + it 'are not returned' do + expect { subject }.to raise_exception(ActiveRecord::RecordNotFound) + end + end + end +end diff --git a/spec/finders/packages/packages_finder_spec.rb b/spec/finders/packages/packages_finder_spec.rb new file mode 100644 index 00000000000..925b003bb8e --- /dev/null +++ b/spec/finders/packages/packages_finder_spec.rb @@ -0,0 +1,90 @@ +# frozen_string_literal: true + +require 'spec_helper' + +RSpec.describe ::Packages::PackagesFinder do + let_it_be(:project) { create(:project) } + let_it_be(:maven_package) { create(:maven_package, project: project, created_at: 2.days.ago, name: 'maven', version: '2.0.0') } + let_it_be(:conan_package) { create(:conan_package, project: project, created_at: 1.day.ago, name: 'conan', version: '1.0.0') } + + describe '#execute' do + let(:params) { {} } + + subject { described_class.new(project, params).execute } + + context 'with package_type' do + let_it_be(:npm_package1) { create(:npm_package, project: project) } + let_it_be(:npm_package2) { create(:npm_package, project: project) } + + context 'conan packages' do + let(:params) { { package_type: 'conan' } } + + it { is_expected.to eq([conan_package]) } + end + + context 'npm packages' do + let(:params) { { package_type: 'npm' } } + + it { is_expected.to match_array([npm_package1, npm_package2]) } + end + end + + context 'with order_by' do + context 'by default is created_at' do + it { is_expected.to eq([maven_package, conan_package]) } + end + + context 'order by name' do + let(:params) { { order_by: 'name' } } + + it { is_expected.to eq([conan_package, maven_package]) } + end + + context 'order by version' do + let(:params) { { order_by: 'version' } } + + it { is_expected.to eq([conan_package, maven_package]) } + end + + context 'order by type' do + let(:params) { { order_by: 'type' } } + + it { is_expected.to eq([maven_package, conan_package]) } + end + end + + context 'with sort' do + context 'by default is ascending' do + it { is_expected.to eq([maven_package, conan_package]) } + end + + context 'can sort descended' do + let(:params) { { sort: 'desc' } } + + it { is_expected.to eq([conan_package, maven_package]) } + end + end + + context 'with package_name' do + let(:params) { { package_name: 'maven' } } + + it { is_expected.to eq([maven_package]) } + end + + context 'with nil params' do + it { is_expected.to match_array([conan_package, maven_package]) } + end + + context 'with processing packages' do + let_it_be(:nuget_package) { create(:nuget_package, project: project, name: Packages::Nuget::CreatePackageService::TEMPORARY_PACKAGE_NAME) } + + it { is_expected.to match_array([conan_package, maven_package]) } + end + + context 'does not include packages without version number' do + let_it_be(:package_without_version) { create(:maven_package, project: project, version: nil) } + + it { is_expected.not_to include(package_without_version) } + end + end +end diff --git a/spec/finders/packages/tags_finder_spec.rb b/spec/finders/packages/tags_finder_spec.rb new file mode 100644 index 00000000000..47e1d25debf --- /dev/null +++ b/spec/finders/packages/tags_finder_spec.rb @@ -0,0 +1,68 @@ +# frozen_string_literal: true +require 'spec_helper' + +RSpec.describe Packages::TagsFinder do + let(:package) { create(:npm_package) } + let(:project) { package.project } + let!(:tag1) { create(:packages_tag, package: package) } + let!(:tag2) { create(:packages_tag, package: package) } + let(:package_name) { package.name } + let(:params) { {} } + + describe '#execute' do + subject { described_class.new(project, package_name, params).execute } + + it { is_expected.to match_array([tag1, tag2]) } + + context 'with package type' do + let(:package_maven) { create(:maven_package, project: project) } + let!(:tag_maven) { create(:packages_tag, package: package_maven) } + let(:package_name) { package_maven.name } + let(:params) { { package_type: package_maven.package_type } } + + it { is_expected.to match_array([tag_maven]) } + end + + context 'with blank package type' do + let(:params) { { package_type: ' ' } } + + it { is_expected.to match_array([tag1, tag2]) } + end + + context 'with nil package type' do + let(:params) { { package_type: nil } } + + it { is_expected.to match_array([tag1, tag2]) } + end + + context 'with unknown package name' do + let(:package_name) { 'foobar' } + + it { is_expected.to be_empty } + end + end + + describe '#find_by_name' do + let(:tag_name) { tag1.name } + + subject { described_class.new(project, package_name, params).execute.find_by_name(tag_name) } + + it { is_expected.to eq(tag1) } + + context 'with package type' do + let(:package_maven) { create(:maven_package, project: project) } + let!(:tag_maven) { create(:packages_tag, package: package_maven) } + let(:package_name) { package_maven.name } + let(:params) { { package_type: package_maven.package_type } } + let(:tag_name) { tag_maven.name } + + it { is_expected.to eq(tag_maven) } + end + + context 'with unknown tag_name' do + let(:tag_name) { 'foobar' } + + it { is_expected.to be_nil } + end + end +end -- cgit v1.2.3