spec/frontend/filtered_search/filtered_search_manager_spec.js

@@ -77,7 +77,7 @@ describe('Filtered Search Manager', () => {
     jest.spyOn(FilteredSearchDropdownManager.prototype, 'setDropdown').mockImplementation();
   });
 
-  const initializeManager = () => {
+  const initializeManager = ({ useDefaultState } = {}) => {
     jest.spyOn(FilteredSearchManager.prototype, 'loadSearchParamsFromURL').mockImplementation();
     jest.spyOn(FilteredSearchManager.prototype, 'tokenChange').mockImplementation();
     jest
@@ -88,7 +88,7 @@ describe('Filtered Search Manager', () => {
 
     input = document.querySelector('.filtered-search');
     tokensContainer = document.querySelector('.tokens-container');
-    manager = new FilteredSearchManager({ page });
+    manager = new FilteredSearchManager({ page, useDefaultState });
     manager.setup();
   };
 
@@ -184,17 +184,27 @@ describe('Filtered Search Manager', () => {
   });
 
   describe('search', () => {
-    const defaultParams = '?scope=all&utf8=%E2%9C%93&state=opened';
+    const defaultParams = '?scope=all&utf8=%E2%9C%93';
+    const defaultState = '&state=opened';
 
-    beforeEach(() => {
+    it('should search with a single word', done => {
       initializeManager();
+      input.value = 'searchTerm';
+
+      visitUrl.mockImplementation(url => {
+        expect(url).toEqual(`${defaultParams}&search=searchTerm`);
+        done();
+      });
+
+      manager.search();
     });
 
-    it('should search with a single word', done => {
+    it('sets default state', done => {
+      initializeManager({ useDefaultState: true });
       input.value = 'searchTerm';
 
       visitUrl.mockImplementation(url => {
-        expect(url).toEqual(`${defaultParams}&search=searchTerm`);
+        expect(url).toEqual(`${defaultParams}${defaultState}&search=searchTerm`);
         done();
       });
 
@@ -202,6 +212,7 @@ describe('Filtered Search Manager', () => {
     });
 
     it('should search with multiple words', done => {
+      initializeManager();
       input.value = 'awesome search terms';
 
       visitUrl.mockImplementation(url => {
@@ -213,6 +224,7 @@ describe('Filtered Search Manager', () => {
     });
 
     it('should search with special characters', done => {
+      initializeManager();
       input.value = '~!@#$%^&*()_+{}:<>,.?/';
 
       visitUrl.mockImplementation(url => {
@@ -226,6 +238,7 @@ describe('Filtered Search Manager', () => {
     });
 
     it('should use replacement URL for condition', done => {
+      initializeManager();
       tokensContainer.innerHTML = FilteredSearchSpecHelper.createTokensContainerHTML(
         FilteredSearchSpecHelper.createFilterVisualTokenHTML('milestone', '=', '13', true),
       );
@@ -246,6 +259,7 @@ describe('Filtered Search Manager', () => {
     });
 
     it('removes duplicated tokens', done => {
+      initializeManager();
       tokensContainer.innerHTML = FilteredSearchSpecHelper.createTokensContainerHTML(`
         ${FilteredSearchSpecHelper.createFilterVisualTokenHTML('label', '=', '~bug')}
         ${FilteredSearchSpecHelper.createFilterVisualTokenHTML('label', '=', '~bug')}

spec/lib/gitlab/database/schema_version_files_spec.rb

@@ -4,30 +4,53 @@
 
 RSpec.describe Gitlab::Database::SchemaVersionFiles do
   describe '.touch_all' do
-    let(:versions) { %w[2020123 2020456 2020890] }
-
-    it 'creates a file containing a checksum for each version given' do
+    let(:version1) { '20200123' }
+    let(:version2) { '20200410' }
+    let(:version3) { '20200602' }
+    let(:version4) { '20200809' }
+    let(:relative_schema_directory) { 'db/schema_migrations' }
+    let(:relative_migrate_directory) { 'db/migrate' }
+    let(:relative_post_migrate_directory) { 'db/post_migrate' }
+
+    it 'creates a file containing a checksum for each version with a matching migration' do
       Dir.mktmpdir do |tmpdir|
-        schema_dirpath = Pathname.new(tmpdir).join("test")
-        FileUtils.mkdir_p(schema_dirpath)
+        schema_directory = Pathname.new(tmpdir).join(relative_schema_directory)
+        migrate_directory = Pathname.new(tmpdir).join(relative_migrate_directory)
+        post_migrate_directory = Pathname.new(tmpdir).join(relative_post_migrate_directory)
+
+        FileUtils.mkdir_p(migrate_directory)
+        FileUtils.mkdir_p(post_migrate_directory)
+        FileUtils.mkdir_p(schema_directory)
+
+        migration1_filepath = migrate_directory.join("#{version1}_migration.rb")
+        FileUtils.touch(migration1_filepath)
 
-        old_version_filepath = schema_dirpath.join("2020001")
+        migration2_filepath = post_migrate_directory.join("#{version2}_post_migration.rb")
+        FileUtils.touch(migration2_filepath)
+
+        old_version_filepath = schema_directory.join('20200101')
         FileUtils.touch(old_version_filepath)
 
         expect(File.exist?(old_version_filepath)).to be(true)
 
-        allow(described_class).to receive(:schema_dirpath).and_return(schema_dirpath)
+        allow(described_class).to receive(:schema_directory).and_return(schema_directory)
+        allow(described_class).to receive(:migration_directories).and_return([migrate_directory, post_migrate_directory])
 
-        described_class.touch_all(versions)
+        described_class.touch_all([version1, version2, version3, version4])
 
         expect(File.exist?(old_version_filepath)).to be(false)
-        versions.each do |version|
-          version_filepath = schema_dirpath.join(version)
+        [version1, version2].each do |version|
+          version_filepath = schema_directory.join(version)
           expect(File.exist?(version_filepath)).to be(true)
 
           hashed_value = Digest::SHA256.hexdigest(version)
           expect(File.read(version_filepath)).to eq(hashed_value)
         end
+
+        [version3, version4].each do |version|
+          version_filepath = schema_directory.join(version)
+          expect(File.exist?(version_filepath)).to be(false)
+        end
       end
     end
   end

spec/lib/gitlab/repository_cache_adapter_spec.rb

@@ -212,8 +212,7 @@
       expect(cache).to receive(:expire).with(:rendered_readme)
       expect(cache).to receive(:expire).with(:branch_names)
       expect(redis_set_cache).to receive(:expire).with(:rendered_readme, :branch_names)
-      expect(redis_hash_cache).to receive(:delete).with(:rendered_readme)
-      expect(redis_hash_cache).to receive(:delete).with(:branch_names)
+      expect(redis_hash_cache).to receive(:delete).with(:rendered_readme, :branch_names)
 
       repository.expire_method_caches(%i(rendered_readme branch_names))
     end

spec/lib/gitlab/repository_hash_cache_spec.rb

@@ -48,6 +48,24 @@
     context "key doesn't exist" do
       it { is_expected.to eq(0) }
     end
+
+    context "multiple keys" do
+      before do
+        cache.write(:test1, test_hash)
+        cache.write(:test2, test_hash)
+      end
+
+      it "deletes multiple keys" do
+        cache.delete(:test1, :test2)
+
+        expect(cache.read_members(:test1, ["test"])).to eq("test" => nil)
+        expect(cache.read_members(:test2, ["test"])).to eq("test" => nil)
+      end
+
+      it "returns deleted key count" do
+        expect(cache.delete(:test1, :test2)).to eq(2)
+      end
+    end
   end
 
   describe "#key?" do

spec/models/ci/build_spec.rb

@@ -612,6 +612,62 @@
     end
   end
 
+  describe '#available_artifacts?' do
+    let(:build) { create(:ci_build) }
+
+    subject { build.available_artifacts? }
+
+    context 'when artifacts are not expired' do
+      before do
+        build.artifacts_expire_at = Date.tomorrow
+      end
+
+      context 'when artifacts exist' do
+        before do
+          create(:ci_job_artifact, :archive, job: build)
+        end
+
+        it { is_expected.to be_truthy }
+      end
+
+      context 'when artifacts do not exist' do
+        it { is_expected.to be_falsey }
+      end
+    end
+
+    context 'when artifacts are expired' do
+      before do
+        build.artifacts_expire_at = Date.yesterday
+      end
+
+      context 'when artifacts are not locked' do
+        before do
+          build.pipeline.locked = :unlocked
+        end
+
+        it { is_expected.to be_falsey }
+      end
+
+      context 'when artifacts are locked' do
+        before do
+          build.pipeline.locked = :artifacts_locked
+        end
+
+        context 'when artifacts exist' do
+          before do
+            create(:ci_job_artifact, :archive, job: build)
+          end
+
+          it { is_expected.to be_truthy }
+        end
+
+        context 'when artifacts do not exist' do
+          it { is_expected.to be_falsey }
+        end
+      end
+    end
+  end
+
   describe '#browsable_artifacts?' do
     subject { build.browsable_artifacts? }
 

spec/models/repository_spec.rb

@@ -587,15 +587,19 @@ def create_commit_with_invalid_utf8_path
       end
 
       it "is expired when the branches caches are expired" do
-        expect(cache).to receive(:delete).with(:merged_branch_names).at_least(:once)
+        expect(cache).to receive(:delete) do |*args|
+          expect(args).to include(:merged_branch_names)
+        end
 
-        repository.send(:expire_branches_cache)
+        repository.expire_branches_cache
       end
 
       it "is expired when the repository caches are expired" do
-        expect(cache).to receive(:delete).with(:merged_branch_names).at_least(:once)
+        expect(cache).to receive(:delete) do |*args|
+          expect(args).to include(:merged_branch_names)
+        end
 
-        repository.send(:expire_all_method_caches)
+        repository.expire_all_method_caches
       end
     end
 

spec/serializers/build_details_entity_spec.rb

@@ -185,12 +185,38 @@
       end
     end
 
+    context 'when the build has expired artifacts' do
+      let!(:build) { create(:ci_build, :artifacts, artifacts_expire_at: 7.days.ago) }
+
+      it 'does not expose any artifact actions path' do
+        expect(subject[:artifact].keys).not_to include(:download_path, :browse_path, :keep_path)
+      end
+
+      it 'artifact locked is false' do
+        expect(subject.dig(:artifact, :locked)).to eq(false)
+      end
+
+      context 'when the pipeline is artifacts_locked' do
+        before do
+          build.pipeline.update!(locked: :artifacts_locked)
+        end
+
+        it 'artifact locked is true' do
+          expect(subject.dig(:artifact, :locked)).to eq(true)
+        end
+
+        it 'exposes download and browse artifact actions path' do
+          expect(subject[:artifact].keys).to include(:download_path, :browse_path)
+        end
+      end
+    end
+
     context 'when the build has archive type artifacts' do
       let!(:build) { create(:ci_build, :artifacts, artifacts_expire_at: 7.days.from_now) }
       let!(:report) { create(:ci_job_artifact, :codequality, job: build) }
 
       it 'exposes artifact details' do
-        expect(subject[:artifact].keys).to include(:download_path, :browse_path, :keep_path, :expire_at, :expired)
+        expect(subject[:artifact].keys).to include(:download_path, :browse_path, :keep_path, :expire_at, :expired, :locked)
       end
     end
   end