Add latest changes from gitlab-org/gitlab@master

5 files changed, 281 insertions, 18 deletions

diff --git a/spec/models/abuse_report_spec.rb b/spec/models/abuse_report_spec.rb
index 87a0a2a492c..30639f5a580 100644
--- a/spec/models/abuse_report_spec.rb
+++ b/spec/models/abuse_report_spec.rb
@@ -71,9 +71,8 @@ RSpec.describe AbuseReport, feature_category: :insider_threat do
   end
 
   describe 'scopes' do
-    let!(:reporter) { create(:user, username: 'reporter') }
-    let!(:report1) { create(:abuse_report) }
-    let!(:report2) { create(:abuse_report, :closed, reporter: reporter, category: 'phishing') }
+    let_it_be(:report1) { create(:abuse_report) }
+    let_it_be(:report2) { create(:abuse_report, :closed, category: 'phishing') }
 
     describe '.open' do
       subject(:results) { described_class.open }
diff --git a/spec/models/design_management/design_spec.rb b/spec/models/design_management/design_spec.rb
index 5217b2a4114..cb122fa09fc 100644
--- a/spec/models/design_management/design_spec.rb
+++ b/spec/models/design_management/design_spec.rb
@@ -513,11 +513,11 @@ RSpec.describe DesignManagement::Design, feature_category: :design_management do
   end
 
   describe '#to_reference' do
+    let(:filename)  { 'homescreen.jpg' }
     let(:namespace) { build(:namespace, id: non_existing_record_id, path: 'sample-namespace') }
     let(:project)   { build(:project, name: 'sample-project', namespace: namespace) }
-    let(:group)     { create(:group, name: 'Group', path: 'sample-group') }
+    let(:group)     { build(:group, name: 'Group', path: 'sample-group') }
     let(:issue)     { build(:issue, iid: 1, project: project) }
-    let(:filename)  { 'homescreen.jpg' }
     let(:design)    { build(:design, filename: filename, issue: issue, project: project) }
 
     context 'when nil argument' do
diff --git a/spec/models/issue_spec.rb b/spec/models/issue_spec.rb
index 6e54ac3bd3f..a61a3c5e2ab 100644
--- a/spec/models/issue_spec.rb
+++ b/spec/models/issue_spec.rb
@@ -580,38 +580,38 @@ RSpec.describe Issue, feature_category: :team_planning do
   end
 
   describe '#to_reference' do
-    let(:namespace) { build(:namespace, path: 'sample-namespace') }
-    let(:project)   { build(:project, name: 'sample-project', namespace: namespace) }
-    let(:issue)     { build(:issue, iid: 1, project: project) }
+    let_it_be(:namespace) { create(:namespace, path: 'sample-namespace') }
+    let_it_be(:project)   { create(:project, name: 'sample-project', namespace: namespace) }
+    let_it_be(:issue)     { create(:issue, project: project) }
 
     context 'when nil argument' do
       it 'returns issue id' do
-        expect(issue.to_reference).to eq "#1"
+        expect(issue.to_reference).to eq "##{issue.iid}"
       end
 
       it 'returns complete path to the issue with full: true' do
-        expect(issue.to_reference(full: true)).to eq 'sample-namespace/sample-project#1'
+        expect(issue.to_reference(full: true)).to eq "#{project.full_path}##{issue.iid}"
       end
     end
 
     context 'when argument is a project' do
       context 'when same project' do
         it 'returns issue id' do
-          expect(issue.to_reference(project)).to eq("#1")
+          expect(issue.to_reference(project)).to eq("##{issue.iid}")
         end
 
         it 'returns full reference with full: true' do
-          expect(issue.to_reference(project, full: true)).to eq 'sample-namespace/sample-project#1'
+          expect(issue.to_reference(project, full: true)).to eq "#{project.full_path}##{issue.iid}"
         end
       end
 
       context 'when cross-project in same namespace' do
         let(:another_project) do
-          build(:project, name: 'another-project', namespace: project.namespace)
+          create(:project, name: 'another-project', namespace: project.namespace)
         end
 
         it 'returns a cross-project reference' do
-          expect(issue.to_reference(another_project)).to eq "sample-project#1"
+          expect(issue.to_reference(another_project)).to eq "sample-project##{issue.iid}"
         end
       end
 
@@ -620,7 +620,7 @@ RSpec.describe Issue, feature_category: :team_planning do
         let(:another_namespace_project) { build(:project, path: 'another-project', namespace: another_namespace) }
 
         it 'returns complete path to the issue' do
-          expect(issue.to_reference(another_namespace_project)).to eq 'sample-namespace/sample-project#1'
+          expect(issue.to_reference(another_namespace_project)).to eq "#{project.full_path}##{issue.iid}"
         end
       end
     end
@@ -628,11 +628,11 @@ RSpec.describe Issue, feature_category: :team_planning do
     context 'when argument is a namespace' do
       context 'when same as issue' do
         it 'returns path to the issue with the project name' do
-          expect(issue.to_reference(namespace)).to eq 'sample-project#1'
+          expect(issue.to_reference(namespace)).to eq "sample-project##{issue.iid}"
         end
 
         it 'returns full reference with full: true' do
-          expect(issue.to_reference(namespace, full: true)).to eq 'sample-namespace/sample-project#1'
+          expect(issue.to_reference(namespace, full: true)).to eq "#{project.full_path}##{issue.iid}"
         end
       end
 
@@ -640,12 +640,111 @@ RSpec.describe Issue, feature_category: :team_planning do
         let(:group) { build(:group, name: 'Group', path: 'sample-group') }
 
         it 'returns full path to the issue with full: true' do
-          expect(issue.to_reference(group)).to eq 'sample-namespace/sample-project#1'
+          expect(issue.to_reference(group)).to eq "#{project.full_path}##{issue.iid}"
         end
       end
     end
   end
 
+  describe '#to_reference with table syntax' do
+    using RSpec::Parameterized::TableSyntax
+
+    let_it_be(:user) { create(:user) }
+    let_it_be(:user_namespace) { user.namespace }
+
+    let_it_be(:parent) { create(:group) }
+    let_it_be(:group) { create(:group, parent: parent) }
+    let_it_be(:another_group) { create(:group) }
+
+    let_it_be(:project) { create(:project, namespace: group) }
+    let_it_be(:project_namespace) { project.project_namespace }
+    let_it_be(:same_namespace_project) { create(:project, namespace: group) }
+    let_it_be(:same_namespace_project_namespace) { same_namespace_project.project_namespace }
+
+    let_it_be(:another_namespace_project) { create(:project) }
+    let_it_be(:another_namespace_project_namespace) { another_namespace_project.project_namespace }
+
+    let_it_be(:project_issue) { build(:issue, project: project, iid: 123) }
+    let_it_be(:project_issue_full_reference) { "#{project.full_path}##{project_issue.iid}" }
+
+    let_it_be(:group_issue) { build(:issue, namespace: group, iid: 123) }
+    let_it_be(:group_issue_full_reference) { "#{group.full_path}##{group_issue.iid}" }
+
+    # this one is just theoretically possible, not smth to be supported for real
+    let_it_be(:user_issue) { build(:issue, namespace: user_namespace, iid: 123) }
+    let_it_be(:user_issue_full_reference) { "#{user_namespace.full_path}##{user_issue.iid}" }
+
+    # namespace would be group, project namespace or user namespace
+    where(:issue, :full, :from, :result) do
+      ref(:project_issue) | false | nil                                       | lazy { "##{issue.iid}" }
+      ref(:project_issue) | true  | nil                                       | ref(:project_issue_full_reference)
+      ref(:project_issue) | false | ref(:group)                               | lazy { "#{project.path}##{issue.iid}" }
+      ref(:project_issue) | true  | ref(:group)                               | ref(:project_issue_full_reference)
+      ref(:project_issue) | false | ref(:parent)                              | ref(:project_issue_full_reference)
+      ref(:project_issue) | true  | ref(:parent)                              | ref(:project_issue_full_reference)
+      ref(:project_issue) | false | ref(:project)                             | lazy { "##{issue.iid}" }
+      ref(:project_issue) | true  | ref(:project)                             | ref(:project_issue_full_reference)
+      ref(:project_issue) | false | ref(:project_namespace)                   | lazy { "##{issue.iid}" }
+      ref(:project_issue) | true  | ref(:project_namespace)                   | ref(:project_issue_full_reference)
+      ref(:project_issue) | false | ref(:same_namespace_project)              | lazy { "#{project.path}##{issue.iid}" }
+      ref(:project_issue) | true  | ref(:same_namespace_project)              | ref(:project_issue_full_reference)
+      ref(:project_issue) | false | ref(:same_namespace_project_namespace)    | lazy { "#{project.path}##{issue.iid}" }
+      ref(:project_issue) | true  | ref(:same_namespace_project_namespace)    | ref(:project_issue_full_reference)
+      ref(:project_issue) | false | ref(:another_group)                       | ref(:project_issue_full_reference)
+      ref(:project_issue) | true  | ref(:another_group)                       | ref(:project_issue_full_reference)
+      ref(:project_issue) | false | ref(:another_namespace_project)           | ref(:project_issue_full_reference)
+      ref(:project_issue) | true  | ref(:another_namespace_project)           | ref(:project_issue_full_reference)
+      ref(:project_issue) | false | ref(:another_namespace_project_namespace) | ref(:project_issue_full_reference)
+      ref(:project_issue) | true  | ref(:another_namespace_project_namespace) | ref(:project_issue_full_reference)
+      ref(:project_issue) | false | ref(:user_namespace)                      | ref(:project_issue_full_reference)
+      ref(:project_issue) | true  | ref(:user_namespace)                      | ref(:project_issue_full_reference)
+
+      ref(:group_issue) | false | nil                                         | lazy { "##{issue.iid}" }
+      ref(:group_issue) | true  | nil                                         | ref(:group_issue_full_reference)
+      ref(:group_issue) | false | ref(:user_namespace)                        | ref(:group_issue_full_reference)
+      ref(:group_issue) | true  | ref(:user_namespace)                        | ref(:group_issue_full_reference)
+      ref(:group_issue) | false | ref(:group)                                 | lazy { "##{issue.iid}" }
+      ref(:group_issue) | true  | ref(:group)                                 | ref(:group_issue_full_reference)
+      ref(:group_issue) | false | ref(:parent)                                | lazy { "#{group.path}##{issue.iid}" }
+      ref(:group_issue) | true  | ref(:parent)                                | ref(:group_issue_full_reference)
+      ref(:group_issue) | false | ref(:project)                               | lazy { "#{group.path}##{issue.iid}" }
+      ref(:group_issue) | true  | ref(:project)                               | ref(:group_issue_full_reference)
+      ref(:group_issue) | false | ref(:project_namespace)                     | lazy { "#{group.path}##{issue.iid}" }
+      ref(:group_issue) | true  | ref(:project_namespace)                     | ref(:group_issue_full_reference)
+      ref(:group_issue) | false | ref(:another_group)                         | ref(:group_issue_full_reference)
+      ref(:group_issue) | true  | ref(:another_group)                         | ref(:group_issue_full_reference)
+      ref(:group_issue) | false | ref(:another_namespace_project)             | ref(:group_issue_full_reference)
+      ref(:group_issue) | true  | ref(:another_namespace_project)             | ref(:group_issue_full_reference)
+      ref(:group_issue) | false | ref(:another_namespace_project_namespace)   | ref(:group_issue_full_reference)
+      ref(:group_issue) | true  | ref(:another_namespace_project_namespace)   | ref(:group_issue_full_reference)
+
+      ref(:user_issue) | false | nil                                          | lazy { "##{issue.iid}" }
+      ref(:user_issue) | true  | nil                                          | ref(:user_issue_full_reference)
+      ref(:user_issue) | false | ref(:user_namespace)                         | lazy { "##{issue.iid}" }
+      ref(:user_issue) | true  | ref(:user_namespace)                         | ref(:user_issue_full_reference)
+      ref(:user_issue) | false | ref(:group)                                  | ref(:user_issue_full_reference)
+      ref(:user_issue) | true  | ref(:group)                                  | ref(:user_issue_full_reference)
+      ref(:user_issue) | false | ref(:parent)                                 | ref(:user_issue_full_reference)
+      ref(:user_issue) | true  | ref(:parent)                                 | ref(:user_issue_full_reference)
+      ref(:user_issue) | false | ref(:project)                                | ref(:user_issue_full_reference)
+      ref(:user_issue) | true  | ref(:project)                                | ref(:user_issue_full_reference)
+      ref(:user_issue) | false | ref(:project_namespace)                      | ref(:user_issue_full_reference)
+      ref(:user_issue) | true  | ref(:project_namespace)                      | ref(:user_issue_full_reference)
+      ref(:user_issue) | false | ref(:another_group)                          | ref(:user_issue_full_reference)
+      ref(:user_issue) | true  | ref(:another_group)                          | ref(:user_issue_full_reference)
+      ref(:user_issue) | false | ref(:another_namespace_project)              | ref(:user_issue_full_reference)
+      ref(:user_issue) | true  | ref(:another_namespace_project)              | ref(:user_issue_full_reference)
+      ref(:user_issue) | false | ref(:another_namespace_project_namespace)    | ref(:user_issue_full_reference)
+      ref(:user_issue) | true  | ref(:another_namespace_project_namespace)    | ref(:user_issue_full_reference)
+    end
+
+    with_them do
+      it 'returns correct reference' do
+        expect(issue.to_reference(from, full: full)).to eq(result)
+      end
+    end
+  end
+
   describe '#assignee_or_author?' do
     let(:issue) { create(:issue, project: reusable_project) }
 
diff --git a/spec/models/namespace_spec.rb b/spec/models/namespace_spec.rb
index 2d6ddd74dfd..0553a7d7152 100644
--- a/spec/models/namespace_spec.rb
+++ b/spec/models/namespace_spec.rb
@@ -266,6 +266,117 @@ RSpec.describe Namespace, feature_category: :subgroups do
     end
   end
 
+  describe "ReferencePatternValidation" do
+    subject { described_class.reference_pattern }
+
+    it { is_expected.to match("@group1") }
+    it { is_expected.to match("@group1/group2/group3") }
+    it { is_expected.to match("@1234/1234/1234") }
+    it { is_expected.to match("@.q-w_e") }
+  end
+
+  describe '#to_reference_base' do
+    using RSpec::Parameterized::TableSyntax
+
+    let_it_be(:user) { create(:user) }
+    let_it_be(:user_namespace) { user.namespace }
+
+    let_it_be(:parent) { create(:group) }
+    let_it_be(:group) { create(:group, parent: parent) }
+    let_it_be(:another_group) { create(:group) }
+
+    let_it_be(:project) { create(:project, namespace: group) }
+    let_it_be(:project_namespace) { project.project_namespace }
+
+    let_it_be(:another_namespace_project) { create(:project) }
+    let_it_be(:another_namespace_project_namespace) { another_namespace_project.project_namespace }
+
+    # testing references with namespace being: group, project namespace and user namespace
+    where(:namespace, :full, :from, :result) do
+      ref(:parent)             | false | nil                                       | nil
+      ref(:parent)             | true  | nil                                       | lazy { parent.full_path }
+      ref(:parent)             | false | ref(:group)                               | lazy { parent.path }
+      ref(:parent)             | true  | ref(:group)                               | lazy { parent.full_path }
+      ref(:parent)             | false | ref(:parent)                              | nil
+      ref(:parent)             | true  | ref(:parent)                              | lazy { parent.full_path }
+      ref(:parent)             | false | ref(:project)                             | lazy { parent.path }
+      ref(:parent)             | true  | ref(:project)                             | lazy { parent.full_path }
+      ref(:parent)             | false | ref(:project_namespace)                   | lazy { parent.path }
+      ref(:parent)             | true  | ref(:project_namespace)                   | lazy { parent.full_path }
+      ref(:parent)             | false | ref(:another_group)                       | lazy { parent.full_path }
+      ref(:parent)             | true  | ref(:another_group)                       | lazy { parent.full_path }
+      ref(:parent)             | false | ref(:another_namespace_project)           | lazy { parent.full_path }
+      ref(:parent)             | true  | ref(:another_namespace_project)           | lazy { parent.full_path }
+      ref(:parent)             | false | ref(:another_namespace_project_namespace) | lazy { parent.full_path }
+      ref(:parent)             | true  | ref(:another_namespace_project_namespace) | lazy { parent.full_path }
+      ref(:parent)             | false | ref(:user_namespace)                      | lazy { parent.full_path }
+      ref(:parent)             | true  | ref(:user_namespace)                      | lazy { parent.full_path }
+
+      ref(:group)             | false | nil                                       | nil
+      ref(:group)             | true  | nil                                       | lazy { group.full_path }
+      ref(:group)             | false | ref(:group)                               | nil
+      ref(:group)             | true  | ref(:group)                               | lazy { group.full_path }
+      ref(:group)             | false | ref(:parent)                              | lazy { group.path }
+      ref(:group)             | true  | ref(:parent)                              | lazy { group.full_path }
+      ref(:group)             | false | ref(:project)                             | lazy { group.path }
+      ref(:group)             | true  | ref(:project)                             | lazy { group.full_path }
+      ref(:group)             | false | ref(:project_namespace)                   | lazy { group.path }
+      ref(:group)             | true  | ref(:project_namespace)                   | lazy { group.full_path }
+      ref(:group)             | false | ref(:another_group)                       | lazy { group.full_path }
+      ref(:group)             | true  | ref(:another_group)                       | lazy { group.full_path }
+      ref(:group)             | false | ref(:another_namespace_project)           | lazy { group.full_path }
+      ref(:group)             | true  | ref(:another_namespace_project)           | lazy { group.full_path }
+      ref(:group)             | false | ref(:another_namespace_project_namespace) | lazy { group.full_path }
+      ref(:group)             | true  | ref(:another_namespace_project_namespace) | lazy { group.full_path }
+      ref(:group)             | false | ref(:user_namespace)                      | lazy { group.full_path }
+      ref(:group)             | true  | ref(:user_namespace)                      | lazy { group.full_path }
+
+      ref(:project_namespace) | false | nil                                       | nil
+      ref(:project_namespace) | true  | nil                                       | lazy { project_namespace.full_path }
+      ref(:project_namespace) | false | ref(:group)                               | lazy { project_namespace.path }
+      ref(:project_namespace) | true  | ref(:group)                               | lazy { project_namespace.full_path }
+      ref(:project_namespace) | false | ref(:parent)                              | lazy { project_namespace.full_path }
+      ref(:project_namespace) | true  | ref(:parent)                              | lazy { project_namespace.full_path }
+      ref(:project_namespace) | false | ref(:project)                             | nil
+      ref(:project_namespace) | true  | ref(:project)                             | lazy { project_namespace.full_path }
+      ref(:project_namespace) | false | ref(:project_namespace)                   | nil
+      ref(:project_namespace) | true  | ref(:project_namespace)                   | lazy { project_namespace.full_path }
+      ref(:project_namespace) | false | ref(:another_group)                       | lazy { project_namespace.full_path }
+      ref(:project_namespace) | true  | ref(:another_group)                       | lazy { project_namespace.full_path }
+      ref(:project_namespace) | false | ref(:another_namespace_project)           | lazy { project_namespace.full_path }
+      ref(:project_namespace) | true  | ref(:another_namespace_project)           | lazy { project_namespace.full_path }
+      ref(:project_namespace) | false | ref(:another_namespace_project_namespace) | lazy { project_namespace.full_path }
+      ref(:project_namespace) | true  | ref(:another_namespace_project_namespace) | lazy { project_namespace.full_path }
+      ref(:project_namespace) | false | ref(:user_namespace)                      | lazy { project_namespace.full_path }
+      ref(:project_namespace) | true  | ref(:user_namespace)                      | lazy { project_namespace.full_path }
+
+      ref(:user_namespace)    | false | nil                                       | nil
+      ref(:user_namespace)    | true  | nil                                       | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | false | ref(:user_namespace)                      | nil
+      ref(:user_namespace)    | true  | ref(:user_namespace)                      | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | false | ref(:group)                               | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | true  | ref(:group)                               | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | false | ref(:parent)                              | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | true  | ref(:parent)                              | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | false | ref(:project)                             | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | true  | ref(:project)                             | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | false | ref(:project_namespace)                   | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | true  | ref(:project_namespace)                   | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | false | ref(:another_group)                       | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | true  | ref(:another_group)                       | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | false | ref(:another_namespace_project)           | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | true  | ref(:another_namespace_project)           | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | false | ref(:another_namespace_project_namespace) | lazy { user_namespace.full_path }
+      ref(:user_namespace)    | true  | ref(:another_namespace_project_namespace) | lazy { user_namespace.full_path }
+    end
+
+    with_them do
+      it 'returns correct path' do
+        expect(namespace.to_reference_base(from, full: full)).to eq(result)
+      end
+    end
+  end
+
   describe 'handling STI', :aggregate_failures do
     let(:namespace_type) { nil }
     let(:parent) { nil }
diff --git a/spec/models/project_spec.rb b/spec/models/project_spec.rb
index d11257cbf89..e6f2d373128 100644
--- a/spec/models/project_spec.rb
+++ b/spec/models/project_spec.rb
@@ -1392,6 +1392,60 @@ RSpec.describe Project, factory_default: :keep, feature_category: :projects do
     end
   end
 
+  describe '#to_reference_base' do
+    using RSpec::Parameterized::TableSyntax
+
+    let_it_be(:user) { create(:user) }
+    let_it_be(:user_namespace) { user.namespace }
+
+    let_it_be(:parent) { create(:group) }
+    let_it_be(:group) { create(:group, parent: parent) }
+    let_it_be(:another_group) { create(:group) }
+
+    let_it_be(:project1) { create(:project, namespace: group) }
+    let_it_be(:project_namespace) { project1.project_namespace }
+
+    # different project same group
+    let_it_be(:project2) { create(:project, namespace: group) }
+    let_it_be(:project_namespace2) { project2.project_namespace }
+
+    # different project from different group
+    let_it_be(:project3) { create(:project) }
+    let_it_be(:project_namespace3) { project3.project_namespace }
+
+    # testing references with namespace being: group, project namespace and user namespace
+    where(:project, :full, :from, :result) do
+      ref(:project1) | false | nil                       | nil
+      ref(:project1) | true  | nil                       | lazy { project.full_path }
+      ref(:project1) | false | ref(:group)               | lazy { project.path }
+      ref(:project1) | true  | ref(:group)               | lazy { project.full_path }
+      ref(:project1) | false | ref(:parent)              | lazy { project.full_path }
+      ref(:project1) | true  | ref(:parent)              | lazy { project.full_path }
+      ref(:project1) | false | ref(:project1)            | nil
+      ref(:project1) | true  | ref(:project1)            | lazy { project.full_path }
+      ref(:project1) | false | ref(:project_namespace)   | nil
+      ref(:project1) | true  | ref(:project_namespace)   | lazy { project.full_path }
+      ref(:project1) | false | ref(:project2)            | lazy { project.path }
+      ref(:project1) | true  | ref(:project2)            | lazy { project.full_path }
+      ref(:project1) | false | ref(:project_namespace2)  | lazy { project.path }
+      ref(:project1) | true  | ref(:project_namespace2)  | lazy { project.full_path }
+      ref(:project1) | false | ref(:another_group)       | lazy { project.full_path }
+      ref(:project1) | true  | ref(:another_group)       | lazy { project.full_path }
+      ref(:project1) | false | ref(:project3)            | lazy { project.full_path }
+      ref(:project1) | true  | ref(:project3)            | lazy { project.full_path }
+      ref(:project1) | false | ref(:project_namespace3)  | lazy { project.full_path }
+      ref(:project1) | true  | ref(:project_namespace3)  | lazy { project.full_path }
+      ref(:project1) | false | ref(:user_namespace)      | lazy { project.full_path }
+      ref(:project1) | true  | ref(:user_namespace)      | lazy { project.full_path }
+    end
+
+    with_them do
+      it 'returns correct path' do
+        expect(project.to_reference_base(from, full: full)).to eq(result)
+      end
+    end
+  end
+
   describe '#merge_method' do
     where(:ff, :rebase, :method) do
       true  | true  | :ff