Add latest changes from gitlab-org/gitlab@master

7 files changed, 550 insertions, 44 deletions

diff --git a/spec/lib/error_tracking/collector/payload_validator_spec.rb b/spec/lib/error_tracking/collector/payload_validator_spec.rb
new file mode 100644
index 00000000000..852cf9eac6c
--- /dev/null
+++ b/spec/lib/error_tracking/collector/payload_validator_spec.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ErrorTracking::Collector::PayloadValidator do
+  describe '#valid?' do
+    RSpec.shared_examples 'valid payload' do
+      it 'returns true' do
+        expect(described_class.new.valid?(payload)).to be_truthy
+      end
+    end
+
+    RSpec.shared_examples 'invalid payload' do
+      it 'returns false' do
+        expect(described_class.new.valid?(payload)).to be_falsey
+      end
+    end
+
+    context 'ruby payload' do
+      let(:payload) { Gitlab::Json.parse(fixture_file('error_tracking/parsed_event.json')) }
+
+      it_behaves_like 'valid payload'
+    end
+
+    context 'python payload' do
+      let(:payload) { Gitlab::Json.parse(fixture_file('error_tracking/python_event.json')) }
+
+      it_behaves_like 'valid payload'
+    end
+
+    context 'browser payload' do
+      let(:payload) { Gitlab::Json.parse(fixture_file('error_tracking/browser_event.json')) }
+
+      it_behaves_like 'valid payload'
+    end
+
+    context 'empty payload' do
+      let(:payload) { '' }
+
+      it_behaves_like 'invalid payload'
+    end
+
+    context 'invalid payload' do
+      let(:payload) { { 'foo' => 'bar' } }
+
+      it_behaves_like 'invalid payload'
+    end
+  end
+end
diff --git a/spec/lib/gitlab/background_migration/add_primary_email_to_emails_if_user_confirmed_spec.rb b/spec/lib/gitlab/background_migration/add_primary_email_to_emails_if_user_confirmed_spec.rb
new file mode 100644
index 00000000000..b50a55a9e41
--- /dev/null
+++ b/spec/lib/gitlab/background_migration/add_primary_email_to_emails_if_user_confirmed_spec.rb
@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Gitlab::BackgroundMigration::AddPrimaryEmailToEmailsIfUserConfirmed do
+  let(:users) { table(:users) }
+  let(:emails) { table(:emails) }
+
+  let!(:unconfirmed_user) { users.create!(name: 'unconfirmed', email: 'unconfirmed@example.com', confirmed_at: nil, projects_limit: 100) }
+  let!(:confirmed_user_1) { users.create!(name: 'confirmed-1', email: 'confirmed-1@example.com', confirmed_at: 1.day.ago, projects_limit: 100) }
+  let!(:confirmed_user_2) { users.create!(name: 'confirmed-2', email: 'confirmed-2@example.com', confirmed_at: 1.day.ago, projects_limit: 100) }
+  let!(:email) { emails.create!(user_id: confirmed_user_1.id, email: 'confirmed-1@example.com', confirmed_at: 1.day.ago) }
+
+  let(:perform) { described_class.new.perform(users.first.id, users.last.id) }
+
+  it 'adds the primary email of confirmed users to Emails, unless already added', :aggregate_failures do
+    expect(emails.where(email: [unconfirmed_user.email, confirmed_user_2.email])).to be_empty
+
+    expect { perform }.not_to raise_error
+
+    expect(emails.where(email: unconfirmed_user.email).count).to eq(0)
+    expect(emails.where(email: confirmed_user_1.email, user_id: confirmed_user_1.id).count).to eq(1)
+    expect(emails.where(email: confirmed_user_2.email, user_id: confirmed_user_2.id).count).to eq(1)
+
+    email_2 = emails.find_by(email: confirmed_user_2.email, user_id: confirmed_user_2.id)
+    expect(email_2.confirmed_at).to eq(confirmed_user_2.reload.confirmed_at)
+  end
+
+  it 'sets timestamps on the created Emails' do
+    perform
+
+    email_2 = emails.find_by(email: confirmed_user_2.email, user_id: confirmed_user_2.id)
+
+    expect(email_2.created_at).not_to be_nil
+    expect(email_2.updated_at).not_to be_nil
+  end
+
+  context 'when a range of IDs is specified' do
+    let!(:confirmed_user_3) { users.create!(name: 'confirmed-3', email: 'confirmed-3@example.com', confirmed_at: 1.hour.ago, projects_limit: 100) }
+    let!(:confirmed_user_4) { users.create!(name: 'confirmed-4', email: 'confirmed-4@example.com', confirmed_at: 1.hour.ago, projects_limit: 100) }
+
+    it 'only acts on the specified range of IDs', :aggregate_failures do
+      expect do
+        described_class.new.perform(confirmed_user_2.id, confirmed_user_3.id)
+      end.to change { Email.count }.by(2)
+      expect(emails.where(email: confirmed_user_4.email).count).to eq(0)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/background_migration/fix_merge_request_diff_commit_users_spec.rb b/spec/lib/gitlab/background_migration/fix_merge_request_diff_commit_users_spec.rb
new file mode 100644
index 00000000000..ffed0b517f9
--- /dev/null
+++ b/spec/lib/gitlab/background_migration/fix_merge_request_diff_commit_users_spec.rb
@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# The underlying migration relies on the global models (e.g. Project). This
+# means we also need to use FactoryBot factories to ensure everything is
+# operating using the same types. If we use `table()` and similar methods we
+# would have to duplicate a lot of logic just for these tests.
+#
+# rubocop: disable RSpec/FactoriesInMigrationSpecs
+RSpec.describe Gitlab::BackgroundMigration::FixMergeRequestDiffCommitUsers do
+  let(:migration) { described_class.new }
+
+  describe '#perform' do
+    context 'when the project exists' do
+      it 'processes the project' do
+        project = create(:project)
+
+        expect(migration).to receive(:process).with(project)
+        expect(migration).to receive(:schedule_next_job)
+
+        migration.perform(project.id)
+      end
+
+      it 'marks the background job as finished' do
+        project = create(:project)
+
+        Gitlab::Database::BackgroundMigrationJob.create!(
+          class_name: 'FixMergeRequestDiffCommitUsers',
+          arguments: [project.id]
+        )
+
+        migration.perform(project.id)
+
+        job = Gitlab::Database::BackgroundMigrationJob
+          .find_by(class_name: 'FixMergeRequestDiffCommitUsers')
+
+        expect(job.status).to eq('succeeded')
+      end
+    end
+
+    context 'when the project does not exist' do
+      it 'does nothing' do
+        expect(migration).not_to receive(:process)
+        expect(migration).to receive(:schedule_next_job)
+
+        migration.perform(-1)
+      end
+    end
+  end
+
+  describe '#update_commit' do
+    let(:project) { create(:project, :repository) }
+    let(:mr) do
+      create(
+        :merge_request_with_diffs,
+        source_project: project,
+        target_project: project
+      )
+    end
+
+    let(:diff) { mr.merge_request_diffs.first }
+    let(:commit) { project.commit }
+
+    def update_row(migration, project, diff, row)
+      migration.update_commit(project, row)
+
+      diff
+        .merge_request_diff_commits
+        .find_by(sha: row.sha, relative_order: row.relative_order)
+    end
+
+    it 'populates missing commit authors' do
+      commit_row = create(
+        :merge_request_diff_commit,
+        merge_request_diff: diff,
+        sha: commit.sha,
+        relative_order: 9000
+      )
+
+      updated = update_row(migration, project, diff, commit_row)
+
+      expect(updated.commit_author.name).to eq(commit.to_hash[:author_name])
+      expect(updated.commit_author.email).to eq(commit.to_hash[:author_email])
+    end
+
+    it 'populates missing committers' do
+      commit_row = create(
+        :merge_request_diff_commit,
+        merge_request_diff: diff,
+        sha: commit.sha,
+        relative_order: 9000
+      )
+
+      updated = update_row(migration, project, diff, commit_row)
+
+      expect(updated.committer.name).to eq(commit.to_hash[:committer_name])
+      expect(updated.committer.email).to eq(commit.to_hash[:committer_email])
+    end
+
+    it 'leaves existing commit authors as-is' do
+      user = create(:merge_request_diff_commit_user)
+      commit_row = create(
+        :merge_request_diff_commit,
+        merge_request_diff: diff,
+        sha: commit.sha,
+        relative_order: 9000,
+        commit_author: user
+      )
+
+      updated = update_row(migration, project, diff, commit_row)
+
+      expect(updated.commit_author).to eq(user)
+    end
+
+    it 'leaves existing committers as-is' do
+      user = create(:merge_request_diff_commit_user)
+      commit_row = create(
+        :merge_request_diff_commit,
+        merge_request_diff: diff,
+        sha: commit.sha,
+        relative_order: 9000,
+        committer: user
+      )
+
+      updated = update_row(migration, project, diff, commit_row)
+
+      expect(updated.committer).to eq(user)
+    end
+
+    it 'does nothing when both the author and committer are present' do
+      user = create(:merge_request_diff_commit_user)
+      commit_row = create(
+        :merge_request_diff_commit,
+        merge_request_diff: diff,
+        sha: commit.sha,
+        relative_order: 9000,
+        committer: user,
+        commit_author: user
+      )
+
+      recorder = ActiveRecord::QueryRecorder.new do
+        migration.update_commit(project, commit_row)
+      end
+
+      expect(recorder.count).to be_zero
+    end
+
+    it 'does nothing if the commit does not exist in Git' do
+      user = create(:merge_request_diff_commit_user)
+      commit_row = create(
+        :merge_request_diff_commit,
+        merge_request_diff: diff,
+        sha: 'kittens',
+        relative_order: 9000,
+        committer: user,
+        commit_author: user
+      )
+
+      recorder = ActiveRecord::QueryRecorder.new do
+        migration.update_commit(project, commit_row)
+      end
+
+      expect(recorder.count).to be_zero
+    end
+
+    it 'does nothing when the committer/author are missing in the Git commit' do
+      user = create(:merge_request_diff_commit_user)
+      commit_row = create(
+        :merge_request_diff_commit,
+        merge_request_diff: diff,
+        sha: commit.sha,
+        relative_order: 9000,
+        committer: user,
+        commit_author: user
+      )
+
+      allow(migration).to receive(:find_or_create_user).and_return(nil)
+
+      recorder = ActiveRecord::QueryRecorder.new do
+        migration.update_commit(project, commit_row)
+      end
+
+      expect(recorder.count).to be_zero
+    end
+  end
+
+  describe '#schedule_next_job' do
+    it 'schedules the next background migration' do
+      Gitlab::Database::BackgroundMigrationJob
+        .create!(class_name: 'FixMergeRequestDiffCommitUsers', arguments: [42])
+
+      expect(BackgroundMigrationWorker)
+        .to receive(:perform_in)
+        .with(2.minutes, 'FixMergeRequestDiffCommitUsers', [42])
+
+      migration.schedule_next_job
+    end
+
+    it 'does nothing when there are no jobs' do
+      expect(BackgroundMigrationWorker)
+        .not_to receive(:perform_in)
+
+      migration.schedule_next_job
+    end
+  end
+
+  describe '#find_commit' do
+    let(:project) { create(:project, :repository) }
+
+    it 'finds a commit using Git' do
+      commit = project.commit
+      found = migration.find_commit(project, commit.sha)
+
+      expect(found).to eq(commit.to_hash)
+    end
+
+    it 'caches the results' do
+      commit = project.commit
+
+      migration.find_commit(project, commit.sha)
+
+      expect { migration.find_commit(project, commit.sha) }
+        .not_to change { Gitlab::GitalyClient.get_request_count }
+    end
+
+    it 'returns an empty hash if the commit does not exist' do
+      expect(migration.find_commit(project, 'kittens')).to eq({})
+    end
+  end
+
+  describe '#find_or_create_user' do
+    let(:project) { create(:project, :repository) }
+
+    it 'creates missing users' do
+      commit = project.commit.to_hash
+      id = migration.find_or_create_user(commit, :author_name, :author_email)
+
+      expect(MergeRequest::DiffCommitUser.count).to eq(1)
+
+      created = MergeRequest::DiffCommitUser.first
+
+      expect(created.name).to eq(commit[:author_name])
+      expect(created.email).to eq(commit[:author_email])
+      expect(created.id).to eq(id)
+    end
+
+    it 'returns users that already exist' do
+      commit = project.commit.to_hash
+      user1 = migration.find_or_create_user(commit, :author_name, :author_email)
+      user2 = migration.find_or_create_user(commit, :author_name, :author_email)
+
+      expect(user1).to eq(user2)
+    end
+
+    it 'caches the results' do
+      commit = project.commit.to_hash
+
+      migration.find_or_create_user(commit, :author_name, :author_email)
+
+      recorder = ActiveRecord::QueryRecorder.new do
+        migration.find_or_create_user(commit, :author_name, :author_email)
+      end
+
+      expect(recorder.count).to be_zero
+    end
+
+    it 'returns nil if the commit details are missing' do
+      id = migration.find_or_create_user({}, :author_name, :author_email)
+
+      expect(id).to be_nil
+    end
+  end
+
+  describe '#matches_row' do
+    it 'returns the query matches for the composite primary key' do
+      row = double(:commit, merge_request_diff_id: 4, relative_order: 5)
+      arel = migration.matches_row(row)
+
+      expect(arel.to_sql).to eq(
+        '("merge_request_diff_commits"."merge_request_diff_id", "merge_request_diff_commits"."relative_order") = (4, 5)'
+      )
+    end
+  end
+end
+# rubocop: enable RSpec/FactoriesInMigrationSpecs
diff --git a/spec/lib/gitlab/gpg/invalid_gpg_signature_updater_spec.rb b/spec/lib/gitlab/gpg/invalid_gpg_signature_updater_spec.rb
index c1516a48b80..771f6e1ec46 100644
--- a/spec/lib/gitlab/gpg/invalid_gpg_signature_updater_spec.rb
+++ b/spec/lib/gitlab/gpg/invalid_gpg_signature_updater_spec.rb
@@ -140,6 +140,8 @@ RSpec.describe Gitlab::Gpg::InvalidGpgSignatureUpdater do
           key: GpgHelpers::User1.public_key,
           user: user
 
+        user.reload # necessary to reload the association with gpg_keys
+
         expect(invalid_gpg_signature.reload.verification_status).to eq 'unverified_key'
 
         # InvalidGpgSignatureUpdater is called by the after_update hook
diff --git a/spec/lib/gitlab/import_export/project/object_builder_spec.rb b/spec/lib/gitlab/import_export/project/object_builder_spec.rb
index 4c9f9f7c690..42598047500 100644
--- a/spec/lib/gitlab/import_export/project/object_builder_spec.rb
+++ b/spec/lib/gitlab/import_export/project/object_builder_spec.rb
@@ -176,4 +176,118 @@ RSpec.describe Gitlab::ImportExport::Project::ObjectBuilder do
       expect(found.email).to eq('alice@example.com')
     end
   end
+
+  context 'merge request diff commits' do
+    context 'when the "committer" object is present' do
+      it 'uses this object as the committer' do
+        user = MergeRequest::DiffCommitUser
+          .find_or_create('Alice', 'alice@example.com')
+
+        commit = described_class.build(
+          MergeRequestDiffCommit,
+          {
+            'committer' => user,
+            'committer_name' => 'Bla',
+            'committer_email' => 'bla@example.com',
+            'author_name' => 'Bla',
+            'author_email' => 'bla@example.com'
+          }
+        )
+
+        expect(commit.committer).to eq(user)
+      end
+    end
+
+    context 'when the "committer" object is missing' do
+      it 'creates one from the committer name and Email' do
+        commit = described_class.build(
+          MergeRequestDiffCommit,
+          {
+            'committer_name' => 'Alice',
+            'committer_email' => 'alice@example.com',
+            'author_name' => 'Alice',
+            'author_email' => 'alice@example.com'
+          }
+        )
+
+        expect(commit.committer.name).to eq('Alice')
+        expect(commit.committer.email).to eq('alice@example.com')
+      end
+    end
+
+    context 'when the "commit_author" object is present' do
+      it 'uses this object as the author' do
+        user = MergeRequest::DiffCommitUser
+          .find_or_create('Alice', 'alice@example.com')
+
+        commit = described_class.build(
+          MergeRequestDiffCommit,
+          {
+            'committer_name' => 'Alice',
+            'committer_email' => 'alice@example.com',
+            'commit_author' => user,
+            'author_name' => 'Bla',
+            'author_email' => 'bla@example.com'
+          }
+        )
+
+        expect(commit.commit_author).to eq(user)
+      end
+    end
+
+    context 'when the "commit_author" object is missing' do
+      it 'creates one from the author name and Email' do
+        commit = described_class.build(
+          MergeRequestDiffCommit,
+          {
+            'committer_name' => 'Alice',
+            'committer_email' => 'alice@example.com',
+            'author_name' => 'Alice',
+            'author_email' => 'alice@example.com'
+          }
+        )
+
+        expect(commit.commit_author.name).to eq('Alice')
+        expect(commit.commit_author.email).to eq('alice@example.com')
+      end
+    end
+  end
+
+  describe '#find_or_create_diff_commit_user' do
+    context 'when the user already exists' do
+      it 'returns the existing user' do
+        user = MergeRequest::DiffCommitUser
+          .find_or_create('Alice', 'alice@example.com')
+
+        found = described_class
+          .new(MergeRequestDiffCommit, {})
+          .send(:find_or_create_diff_commit_user, user.name, user.email)
+
+        expect(found).to eq(user)
+      end
+    end
+
+    context 'when the user does not exist' do
+      it 'creates the user' do
+        found = described_class
+          .new(MergeRequestDiffCommit, {})
+          .send(:find_or_create_diff_commit_user, 'Alice', 'alice@example.com')
+
+        expect(found.name).to eq('Alice')
+        expect(found.email).to eq('alice@example.com')
+      end
+    end
+
+    it 'caches the results' do
+      builder = described_class.new(MergeRequestDiffCommit, {})
+
+      builder.send(:find_or_create_diff_commit_user, 'Alice', 'alice@example.com')
+
+      record = ActiveRecord::QueryRecorder.new do
+        builder.send(:find_or_create_diff_commit_user, 'Alice', 'alice@example.com')
+      end
+
+      expect(record.count).to eq(1)
+    end
+  end
 end
diff --git a/spec/lib/gitlab/spamcheck/client_spec.rb b/spec/lib/gitlab/spamcheck/client_spec.rb
index 15e963fe423..e542ce455bb 100644
--- a/spec/lib/gitlab/spamcheck/client_spec.rb
+++ b/spec/lib/gitlab/spamcheck/client_spec.rb
@@ -82,7 +82,7 @@ RSpec.describe Gitlab::Spamcheck::Client do
     end
   end
 
-  describe '#build_user_proto_buf', :aggregate_failures do
+  describe '#build_user_protobuf', :aggregate_failures do
     it 'builds the expected protobuf object' do
       user_pb = described_class.new.send(:build_user_protobuf, user)
       expect(user_pb.username).to eq user.username
diff --git a/spec/lib/gitlab/x509/signature_spec.rb b/spec/lib/gitlab/x509/signature_spec.rb
index 7ba15faf910..0e34d5393d6 100644
--- a/spec/lib/gitlab/x509/signature_spec.rb
+++ b/spec/lib/gitlab/x509/signature_spec.rb
@@ -12,7 +12,7 @@ RSpec.describe Gitlab::X509::Signature do
   end
 
   shared_examples "a verified signature" do
-    let_it_be(:user) { create(:user, email: X509Helpers::User1.certificate_email) }
+    let!(:user) { create(:user, email: X509Helpers::User1.certificate_email) }
 
     subject(:signature) do
       described_class.new(
@@ -30,10 +30,12 @@ RSpec.describe Gitlab::X509::Signature do
       expect(signature.verification_status).to eq(:verified)
     end
 
-    it "returns an unverified signature if the email matches but isn't confirmed" do
-      user.update!(confirmed_at: nil)
+    context "if the email matches but isn't confirmed" do
+      let!(:user) { create(:user, :unconfirmed, email: X509Helpers::User1.certificate_email) }
 
-      expect(signature.verification_status).to eq(:unverified)
+      it "returns an unverified signature" do
+        expect(signature.verification_status).to eq(:unverified)
+      end
     end
 
     it 'returns an unverified signature if email does not match' do
@@ -297,7 +299,7 @@ RSpec.describe Gitlab::X509::Signature do
     end
 
     context 'verified signature' do
-      let_it_be(:user) { create(:user, email: X509Helpers::User1.certificate_email) }
+      let_it_be(:user) { create(:user, :unconfirmed, email: X509Helpers::User1.certificate_email) }
 
       subject(:signature) do
         described_class.new(
@@ -316,52 +318,56 @@ RSpec.describe Gitlab::X509::Signature do
           allow(OpenSSL::X509::Store).to receive(:new).and_return(store)
         end
 
-        it 'returns a verified signature if email does match' do
-          expect(signature.x509_certificate).to have_attributes(certificate_attributes)
-          expect(signature.x509_certificate.x509_issuer).to have_attributes(issuer_attributes)
-          expect(signature.verified_signature).to be_truthy
-          expect(signature.verification_status).to eq(:verified)
-        end
+        context 'when user email is confirmed' do
+          before_all do
+            user.confirm
+          end
 
-        it "returns an unverified signature if the email matches but isn't confirmed" do
-          user.update!(confirmed_at: nil)
+          it 'returns a verified signature if email does match', :ggregate_failures do
+            expect(signature.x509_certificate).to have_attributes(certificate_attributes)
+            expect(signature.x509_certificate.x509_issuer).to have_attributes(issuer_attributes)
+            expect(signature.verified_signature).to be_truthy
+            expect(signature.verification_status).to eq(:verified)
+          end
 
-          expect(signature.verification_status).to eq(:unverified)
-        end
+          it 'returns an unverified signature if email does not match', :aggregate_failures do
+            signature = described_class.new(
+              X509Helpers::User1.signed_tag_signature,
+              X509Helpers::User1.signed_tag_base_data,
+              "gitlab@example.com",
+              X509Helpers::User1.signed_commit_time
+            )
+
+            expect(signature.x509_certificate).to have_attributes(certificate_attributes)
+            expect(signature.x509_certificate.x509_issuer).to have_attributes(issuer_attributes)
+            expect(signature.verified_signature).to be_truthy
+            expect(signature.verification_status).to eq(:unverified)
+          end
 
-        it 'returns an unverified signature if email does not match' do
-          signature = described_class.new(
-            X509Helpers::User1.signed_tag_signature,
-            X509Helpers::User1.signed_tag_base_data,
-            "gitlab@example.com",
-            X509Helpers::User1.signed_commit_time
-          )
+          it 'returns an unverified signature if email does match and time is wrong', :aggregate_failures do
+            signature = described_class.new(
+              X509Helpers::User1.signed_tag_signature,
+              X509Helpers::User1.signed_tag_base_data,
+              X509Helpers::User1.certificate_email,
+              Time.new(2020, 2, 22)
+            )
+
+            expect(signature.x509_certificate).to have_attributes(certificate_attributes)
+            expect(signature.x509_certificate.x509_issuer).to have_attributes(issuer_attributes)
+            expect(signature.verified_signature).to be_falsey
+            expect(signature.verification_status).to eq(:unverified)
+          end
 
-          expect(signature.x509_certificate).to have_attributes(certificate_attributes)
-          expect(signature.x509_certificate.x509_issuer).to have_attributes(issuer_attributes)
-          expect(signature.verified_signature).to be_truthy
-          expect(signature.verification_status).to eq(:unverified)
-        end
+          it 'returns an unverified signature if certificate is revoked' do
+            expect(signature.verification_status).to eq(:verified)
 
-        it 'returns an unverified signature if email does match and time is wrong' do
-          signature = described_class.new(
-            X509Helpers::User1.signed_tag_signature,
-            X509Helpers::User1.signed_tag_base_data,
-            X509Helpers::User1.certificate_email,
-            Time.new(2020, 2, 22)
-          )
+            signature.x509_certificate.revoked!
 
-          expect(signature.x509_certificate).to have_attributes(certificate_attributes)
-          expect(signature.x509_certificate.x509_issuer).to have_attributes(issuer_attributes)
-          expect(signature.verified_signature).to be_falsey
-          expect(signature.verification_status).to eq(:unverified)
+            expect(signature.verification_status).to eq(:unverified)
+          end
         end
 
-        it 'returns an unverified signature if certificate is revoked' do
-          expect(signature.verification_status).to eq(:verified)
-
-          signature.x509_certificate.revoked!
-
+        it 'returns an unverified signature if the email matches but is not confirmed' do
           expect(signature.verification_status).to eq(:unverified)
         end
       end