Add latest changes from gitlab-org/gitlab@12-7-stable-ee

spec/frontend/diffs/components/diff_stats_spec.js

 import { shallowMount } from '@vue/test-utils';
+import Icon from '~/vue_shared/components/icon.vue';
 import DiffStats from '~/diffs/components/diff_stats.vue';
 describe('diff_stats', () => {
@@ -23,11 +24,18 @@ describe('diff_stats', () => {
       },
     });
-    const findFileLine = name => wrapper.find(name);
-    const additions = findFileLine('.js-file-addition-line');
-    const deletions = findFileLine('.js-file-deletion-line');
-    expect(additions.text()).toBe('100');
-    expect(deletions.text()).toBe('200');
+    const findIcon = name =>
+      wrapper
+        .findAll(Icon)
+        .filter(c => c.attributes('name') === name)
+        .at(0).element.parentNode;
+    const additions = findIcon('file-addition');
+    const deletions = findIcon('file-deletion');
+    const filesChanged = findIcon('doc-code');
+
+    expect(additions.textContent).toContain('100');
+    expect(deletions.textContent).toContain('200');
+    expect(filesChanged.textContent).toContain('300');
   });
 });

spec/frontend/vue_shared/components/changed_file_icon_spec.js

@@ -56,10 +56,10 @@ describe('Changed file icon', () => {
   describe.each`
     file                      | iconName                 | tooltipText                           | desc
-    ${changedFile()}          | ${'file-modified-solid'} | ${'Unstaged modification'}            | ${'with file changed'}
+    ${changedFile()}          | ${'file-modified'}       | ${'Unstaged modification'}            | ${'with file changed'}
     ${stagedFile()}           | ${'file-modified-solid'} | ${'Staged modification'}              | ${'with file staged'}
-    ${changedAndStagedFile()} | ${'file-modified-solid'} | ${'Unstaged and staged modification'} | ${'with file changed and staged'}
-    ${newFile()}              | ${'file-addition-solid'} | ${'Unstaged addition'}                | ${'with file new'}
+    ${changedAndStagedFile()} | ${'file-modified'}       | ${'Unstaged and staged modification'} | ${'with file changed and staged'}
+    ${newFile()}              | ${'file-addition'}       | ${'Unstaged addition'}                | ${'with file new'}
   `('$desc', ({ file, iconName, tooltipText }) => {
     beforeEach(() => {
       factory({ file });

spec/javascripts/ide/components/repo_tab_spec.js

@@ -93,13 +93,13 @@ describe('RepoTab', () => {
     Vue.nextTick()
       .then(() => {
-        expect(vm.$el.querySelector('.file-modified-solid')).toBeNull();
+        expect(vm.$el.querySelector('.file-modified')).toBeNull();
         vm.$el.dispatchEvent(new Event('mouseout'));
       })
       .then(Vue.nextTick)
       .then(() => {
-        expect(vm.$el.querySelector('.file-modified-solid')).not.toBeNull();
+        expect(vm.$el.querySelector('.file-modified')).not.toBeNull();
         done();
       })

spec/lib/gitlab/auth/ldap/user_spec.rb

@@ -139,6 +139,18 @@ describe Gitlab::Auth::LDAP::User do
         expect(gl_user).to be_confirmed
       end
     end
+
+    context 'when the current minimum password length is different from the default minimum password length' do
+      before do
+        stub_application_setting minimum_password_length: 21
+      end
+
+      it 'creates the user' do
+        ldap_user.save
+
+        expect(gl_user).to be_persisted
+      end
+    end
   end
   describe 'updating email' do

spec/lib/gitlab/auth/o_auth/user_spec.rb

@@ -86,6 +86,20 @@ describe Gitlab::Auth::OAuth::User do
         end
       end
+      context 'when the current minimum password length is different from the default minimum password length' do
+        before do
+          stub_application_setting minimum_password_length: 21
+        end
+
+        it 'creates the user' do
+          stub_omniauth_config(allow_single_sign_on: [provider])
+
+          oauth_user.save
+
+          expect(gl_user).to be_persisted
+        end
+      end
+
       it 'marks user as having password_automatically_set' do
         stub_omniauth_config(allow_single_sign_on: [provider], external_providers: [provider])

spec/lib/gitlab/auth/saml/user_spec.rb

@@ -325,6 +325,18 @@ describe Gitlab::Auth::Saml::User do
           expect(gl_user).to be_confirmed
         end
       end
+
+      context 'when the current minimum password length is different from the default minimum password length' do
+        before do
+          stub_application_setting minimum_password_length: 21
+        end
+
+        it 'creates the user' do
+          saml_user.save
+
+          expect(gl_user).to be_persisted
+        end
+      end
     end
     describe 'blocking' do

spec/lib/gitlab/bitbucket_server_import/importer_spec.rb

@@ -67,6 +67,7 @@ describe Gitlab::BitbucketServerImport::Importer do
         author_email: project.owner.email,
         created_at: Time.now,
         updated_at: Time.now,
+        raw: {},
         merged?: true)
       allow(subject.client).to receive(:pull_requests).and_return([pull_request])
@@ -239,6 +240,13 @@ describe Gitlab::BitbucketServerImport::Importer do
       expect(notes.first.note).to start_with('*Comment on .gitmodules')
       expect(notes.second.note).to start_with('*Comment on .gitmodules')
     end
+
+    it 'reports an error if an exception is raised' do
+      allow(subject).to receive(:import_bitbucket_pull_request).and_raise(RuntimeError)
+      expect(Gitlab::ErrorTracking).to receive(:log_exception)
+
+      subject.execute
+    end
   end
   describe 'inaccessible branches' do

spec/migrations/20200123155929_remove_invalid_jira_data_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+require Rails.root.join('db', 'post_migrate', '20200123155929_remove_invalid_jira_data.rb')
+
+describe RemoveInvalidJiraData, :migration do
+  let(:jira_tracker_data) { table(:jira_tracker_data) }
+  let(:services) { table(:services) }
+
+  let(:service) { services.create(id: 1) }
+  let(:data) do
+    {
+      service_id: service.id,
+      encrypted_api_url: 'http:url.com',
+      encrypted_api_url_iv: 'somevalue',
+      encrypted_url: 'http:url.com',
+      encrypted_url_iv: 'somevalue',
+      encrypted_username: 'username',
+      encrypted_username_iv: 'somevalue',
+      encrypted_password: 'username',
+      encrypted_password_iv: 'somevalue'
+    }
+  end
+
+  let!(:valid_data) { jira_tracker_data.create(data) }
+  let!(:empty_data) { jira_tracker_data.create(service_id: service.id) }
+  let!(:invalid_api_url) do
+    data[:encrypted_api_url_iv] = nil
+    jira_tracker_data.create(data)
+  end
+  let!(:missing_api_url) do
+    data[:encrypted_api_url] = ''
+    data[:encrypted_api_url_iv] = nil
+    jira_tracker_data.create(data)
+  end
+  let!(:invalid_url) do
+    data[:encrypted_url_iv] = nil
+    jira_tracker_data.create(data)
+  end
+  let!(:missing_url) do
+    data[:encrypted_url] = ''
+    jira_tracker_data.create(data)
+  end
+  let!(:invalid_username) do
+    data[:encrypted_username_iv] = nil
+    jira_tracker_data.create(data)
+  end
+  let!(:missing_username) do
+    data[:encrypted_username] = nil
+    data[:encrypted_username_iv] = nil
+    jira_tracker_data.create(data)
+  end
+  let!(:invalid_password) do
+    data[:encrypted_password_iv] = nil
+    jira_tracker_data.create(data)
+  end
+  let!(:missing_password) do
+    data[:encrypted_password] = nil
+    data[:encrypted_username_iv] = nil
+    jira_tracker_data.create(data)
+  end
+
+  it 'removes the invalid data' do
+    valid_data_records = [valid_data, empty_data, missing_api_url, missing_url, missing_username, missing_password]
+
+    expect { migrate! }.to change { jira_tracker_data.count }.from(10).to(6)
+
+    expect(jira_tracker_data.all).to match_array(valid_data_records)
+  end
+end

spec/models/user_spec.rb

@@ -508,6 +508,20 @@ describe User, :do_not_mock_admin_mode do
       end
     end
+    describe '.random_password' do
+      let(:random_password) { described_class.random_password }
+
+      before do
+        expect(User).to receive(:password_length).and_return(88..128)
+      end
+
+      context 'length' do
+        it 'conforms to the current password length settings' do
+          expect(random_password.length).to eq(128)
+        end
+      end
+    end
+
     describe '.password_length' do
       let(:password_length) { described_class.password_length }

spec/services/error_tracking/issue_details_service_spec.rb

@@ -3,24 +3,7 @@
 require 'spec_helper'
 describe ErrorTracking::IssueDetailsService do
-  let_it_be(:user) { create(:user) }
-  let_it_be(:project) { create(:project) }
-
-  let(:sentry_url) { 'https://sentrytest.gitlab.com/api/0/projects/sentry-org/sentry-project' }
-  let(:token) { 'test-token' }
-  let(:result) { subject.execute }
-
-  let(:error_tracking_setting) do
-    create(:project_error_tracking_setting, api_url: sentry_url, token: token, project: project)
-  end
-
-  subject { described_class.new(project, user) }
-
-  before do
-    expect(project).to receive(:error_tracking_setting).at_least(:once).and_return(error_tracking_setting)
-
-    project.add_reporter(user)
-  end
+  include_context 'sentry error tracking context'
   describe '#execute' do
     context 'with authorized user' do

spec/services/error_tracking/issue_latest_event_service_spec.rb

@@ -3,24 +3,7 @@
 require 'spec_helper'
 describe ErrorTracking::IssueLatestEventService do
-  let_it_be(:user) { create(:user) }
-  let_it_be(:project) { create(:project) }
-
-  let(:sentry_url) { 'https://sentrytest.gitlab.com/api/0/projects/sentry-org/sentry-project' }
-  let(:token) { 'test-token' }
-  let(:result) { subject.execute }
-
-  let(:error_tracking_setting) do
-    create(:project_error_tracking_setting, api_url: sentry_url, token: token, project: project)
-  end
-
-  subject { described_class.new(project, user) }
-
-  before do
-    expect(project).to receive(:error_tracking_setting).at_least(:once).and_return(error_tracking_setting)
-
-    project.add_reporter(user)
-  end
+  include_context 'sentry error tracking context'
   describe '#execute' do
     context 'with authorized user' do

spec/services/error_tracking/issue_update_service_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ErrorTracking::IssueUpdateService do
+  include_context 'sentry error tracking context'
+
+  let(:arguments) { { issue_id: 1234, status: 'resolved' } }
+
+  subject { described_class.new(project, user, arguments) }
+
+  shared_examples 'does not perform close issue flow' do
+    it 'does not call the close issue service' do
+      expect(issue_close_service)
+        .not_to receive(:execute)
+    end
+
+    it 'does not create system note' do
+      expect(SystemNoteService).not_to receive(:close_after_error_tracking_resolve)
+    end
+  end
+
+  describe '#execute' do
+    context 'with authorized user' do
+      context 'when update_issue returns success' do
+        let(:update_issue_response) { { updated: true } }
+
+        before do
+          expect(error_tracking_setting)
+            .to receive(:update_issue).and_return(update_issue_response)
+        end
+
+        it 'returns the response' do
+          expect(result).to eq(update_issue_response.merge(status: :success, closed_issue_iid: nil))
+        end
+
+        it 'updates any related issue' do
+          expect(subject).to receive(:update_related_issue)
+
+          result
+        end
+
+        context 'related issue and resolving' do
+          let(:issue) { create(:issue, project: project) }
+          let(:sentry_issue) { create(:sentry_issue, issue: issue) }
+          let(:arguments) { { issue_id: sentry_issue.sentry_issue_identifier, status: 'resolved' } }
+
+          let(:issue_close_service) { spy(:issue_close_service) }
+
+          before do
+            allow_any_instance_of(SentryIssueFinder)
+              .to receive(:execute)
+              .and_return(sentry_issue)
+
+            allow(Issues::CloseService)
+              .to receive(:new)
+              .and_return(issue_close_service)
+          end
+
+          after do
+            result
+          end
+
+          it 'closes the issue' do
+            expect(issue_close_service)
+              .to receive(:execute)
+              .with(issue, system_note: false)
+              .and_return(issue)
+          end
+
+          it 'creates a system note' do
+            expect(SystemNoteService).to receive(:close_after_error_tracking_resolve)
+          end
+
+          it 'returns a response with closed issue' do
+            closed_issue = create(:issue, :closed, project: project)
+
+            expect(issue_close_service)
+              .to receive(:execute)
+              .with(issue, system_note: false)
+              .and_return(closed_issue)
+
+            expect(result).to eq(status: :success, updated: true, closed_issue_iid: closed_issue.iid)
+          end
+
+          context 'issue is already closed' do
+            let(:issue) { create(:issue, :closed, project: project) }
+
+            include_examples 'does not perform close issue flow'
+          end
+
+          context 'status is not resolving' do
+            let(:arguments) { { issue_id: sentry_issue.sentry_issue_identifier, status: 'ignored' } }
+
+            include_examples 'does not perform close issue flow'
+          end
+        end
+      end
+
+      include_examples 'error tracking service sentry error handling', :update_issue
+    end
+
+    include_examples 'error tracking service unauthorized user'
+    include_examples 'error tracking service disabled'
+  end
+end

spec/services/error_tracking/list_issues_service_spec.rb

@@ -3,8 +3,8 @@
 require 'spec_helper'
 describe ErrorTracking::ListIssuesService do
-  let_it_be(:user) { create(:user) }
-  let_it_be(:project) { create(:project) }
+  include_context 'sentry error tracking context'
+
   let(:params) { { search_term: 'something', sort: 'last_seen', cursor: 'some-cursor' } }
   let(:list_sentry_issues_args) do
     {
@@ -16,22 +16,8 @@ describe ErrorTracking::ListIssuesService do
     }
   end
-  let(:sentry_url) { 'https://sentrytest.gitlab.com/api/0/projects/sentry-org/sentry-project' }
-  let(:token) { 'test-token' }
-  let(:result) { subject.execute }
-
-  let(:error_tracking_setting) do
-    create(:project_error_tracking_setting, api_url: sentry_url, token: token, project: project)
-  end
-
   subject { described_class.new(project, user, params) }
-  before do
-    expect(project).to receive(:error_tracking_setting).at_least(:once).and_return(error_tracking_setting)
-
-    project.add_reporter(user)
-  end
-
   describe '#execute' do
     context 'with authorized user' do
       context 'when list_sentry_issues returns issues' do

spec/services/pages_domains/create_acme_order_service_spec.rb

@@ -45,34 +45,12 @@ describe PagesDomains::CreateAcmeOrderService do
     expect { OpenSSL::PKey::RSA.new(saved_order.private_key) }.not_to raise_error
   end
-  it 'properly saves order url' do
+  it 'properly saves order attributes' do
     service.execute
     saved_order = PagesDomainAcmeOrder.last
     expect(saved_order.url).to eq(order_double.url)
-  end
-
-  context 'when order expires in 2 days' do
-    it 'sets expiration time in 2 hours' do
-      Timecop.freeze do
-        service.execute
-
-        saved_order = PagesDomainAcmeOrder.last
-        expect(saved_order.expires_at).to be_like_time(2.hours.from_now)
-      end
-    end
-  end
-
-  context 'when order expires in an hour' do
-    it 'sets expiration time accordingly to order' do
-      Timecop.freeze do
-        allow(order_double).to receive(:expires).and_return(1.hour.from_now)
-        service.execute
-
-        saved_order = PagesDomainAcmeOrder.last
-        expect(saved_order.expires_at).to be_like_time(1.hour.from_now)
-      end
-    end
+    expect(saved_order.expires_at).to be_like_time(order_double.expires)
   end
   it 'properly saves challenge attributes' do

spec/support/shared_contexts/sentry_error_tracking_shared_context.rb

+# frozen_string_literal: true
+
+shared_context 'sentry error tracking context' do
+  let_it_be(:user) { create(:user) }
+  let_it_be(:project) { create(:project) }
+
+  let(:sentry_url) { 'https://sentrytest.gitlab.com/api/0/projects/sentry-org/sentry-project' }
+  let(:token) { 'test-token' }
+  let(:result) { subject.execute }
+
+  subject { described_class.new(project, user) }
+
+  let(:error_tracking_setting) do
+    create(:project_error_tracking_setting, api_url: sentry_url, token: token, project: project)
+  end
+
+  before do
+    expect(project).to receive(:error_tracking_setting).at_least(:once).and_return(error_tracking_setting)
+
+    project.add_reporter(user)
+  end
+end