Merge branch 'ce-to-ee-2017-11-29' into 'master'

CE upstream - Wednesday

Closes gitaly#730, gitaly#656, gitlab-ce#38962, gitlab-ce#40373 et gitlab-ce#40534

See merge request gitlab-org/gitlab-ee!3585

Gemfile.lock

@@ -1191,7 +1191,7 @@ DEPENDENCIES
   sanitize (~> 2.0)
   sass-rails (~> 5.0.6)
   scss_lint (~> 0.54.0)
-  seed-fu (~> 2.3.5)
+  seed-fu (~> 2.3.7)
   select2-rails (~> 3.5.9)
   selenium-webdriver (~> 3.5)
   sentry-raven (~> 2.5.3)

app/assets/javascripts/dispatcher.js

@@ -424,6 +424,7 @@ import initGroupAnalytics from './init_group_analytics';
           projectImport();
           break;
         case 'projects:pipelines:new':
+        case 'projects:pipelines:create':
           new NewBranchForm($('.js-new-pipeline-form'));
           break;
         case 'projects:pipelines:builds':

app/assets/javascripts/lib/utils/common_utils.js

@@ -190,7 +190,7 @@ export const insertText = (target, text) => {
   target.selectionStart = target.selectionEnd = selectionStart + insertedText.length;
 
   // Trigger autosave
-  $(target).trigger('input');
+  target.dispatchEvent(new Event('input'));
 
   // Trigger autosize
   const event = document.createEvent('Event');

app/assets/javascripts/projects_dropdown/components/projects_list_item.vue

@@ -48,6 +48,27 @@ export default {
       }
       return this.projectName;
     },
+    /**
+     * Smartly truncates project namespace by doing two things;
+     * 1. Only include Group names in path by removing project name
+     * 2. Only include first and last group names in the path
+     *    when namespace has more than 2 groups present
+     *
+     * First part (removal of project name from namespace) can be
+     * done from backend but doing so involves migration of
+     * existing project namespaces which is not wise thing to do.
+     */
+    truncatedNamespace() {
+      const namespaceArr = this.namespace.split(' / ');
+      namespaceArr.splice(-1, 1);
+      let namespace = namespaceArr.join(' / ');
+
+      if (namespaceArr.length > 2) {
+        namespace = `${namespaceArr[0]} / ... / ${namespaceArr.pop()}`;
+      }
+
+      return namespace;
+    },
   },
 };
 </script>
@@ -87,9 +108,7 @@ export default {
         <div
           class="project-namespace"
           :title="namespace"
-        >
-          {{namespace}}
-        </div>
+        >{{truncatedNamespace}}</div>
       </div>
     </a>
   </li>

app/assets/stylesheets/framework/dropdowns.scss

@@ -1002,6 +1002,7 @@ header.header-content .dropdown-menu.projects-dropdown-menu {
     max-width: 250px;
     overflow: hidden;
     text-overflow: ellipsis;
+    white-space: nowrap;
   }
 
   &:hover {

app/assets/stylesheets/pages/projects.scss

@@ -299,16 +299,9 @@
     }
 
     svg {
-
-      path {
       fill: $layout-link-gray;
     }
 
-      use {
-        stroke: $layout-link-gray;
-      }
-    }
-
     .fa-caret-down {
       margin-left: 3px;
     }

app/controllers/projects/merge_requests/creations_controller.rb

@@ -67,7 +67,7 @@ class Projects::MergeRequests::CreationsController < Projects::MergeRequests::Ap
 
     if params[:ref].present?
       @ref = params[:ref]
-      @commit = @repository.commit("refs/heads/#{@ref}")
+      @commit = @repository.commit(Gitlab::Git::BRANCH_REF_PREFIX + @ref)
     end
 
     render layout: false
@@ -78,7 +78,7 @@ class Projects::MergeRequests::CreationsController < Projects::MergeRequests::Ap
 
     if params[:ref].present?
       @ref = params[:ref]
-      @commit = @target_project.commit("refs/heads/#{@ref}")
+      @commit = @target_project.commit(Gitlab::Git::BRANCH_REF_PREFIX + @ref)
     end
 
     render layout: false

app/controllers/projects/merge_requests/diffs_controller.rb

@@ -27,7 +27,7 @@ class Projects::MergeRequests::DiffsController < Projects::MergeRequests::Applic
         @merge_request.merge_request_diff
       end
 
-    @merge_request_diffs = @merge_request.merge_request_diffs.viewable.select_without_diff.order_id_desc
+    @merge_request_diffs = @merge_request.merge_request_diffs.viewable.order_id_desc
     @comparable_diffs = @merge_request_diffs.select { |diff| diff.id < @merge_request_diff.id }
 
     if params[:start_sha].present?

app/finders/notes_finder.rb

@@ -104,8 +104,7 @@ class NotesFinder
     query = @params[:search]
     return notes unless query
 
-    pattern = "%#{query}%"
-    notes.where(Note.arel_table[:note].matches(pattern))
+    notes.search(query)
   end
 
   # Notes changed since last fetch

app/models/application_setting.rb

@@ -343,13 +343,13 @@ class ApplicationSetting < ActiveRecord::Base
       user_default_external: false,
       polling_interval_multiplier: 1,
       usage_ping_enabled: Settings.gitlab['usage_ping_enabled'],
+      gitaly_timeout_fast: 10,
+      gitaly_timeout_medium: 30,
+      gitaly_timeout_default: 55,
       slack_app_enabled: false,
       slack_app_id: nil,
       slack_app_secret: nil,
-      slack_app_verification_token: nil,
-      gitaly_timeout_fast: 10,
-      gitaly_timeout_medium: 30,
-      gitaly_timeout_default: 55
+      slack_app_verification_token: nil
     }
   end
 

app/models/ci/runner.rb

 module Ci
   class Runner < ActiveRecord::Base
     extend Gitlab::Ci::Model
+    include Gitlab::SQL::Pattern
     prepend EE::Ci::Runner
 
     RUNNER_QUEUE_EXPIRY_TIME = 60.minutes
@@ -60,10 +61,7 @@ module Ci
     #
     # Returns an ActiveRecord::Relation.
     def self.search(query)
-      t = arel_table
-      pattern = "%#{query}%"
-
-      where(t[:token].matches(pattern).or(t[:description].matches(pattern)))
+      fuzzy_search(query, [:token, :description])
     end
 
     def self.contact_time_deadline

app/models/concerns/issuable.rb

@@ -121,9 +121,7 @@ module Issuable
     #
     # Returns an ActiveRecord::Relation.
     def search(query)
-      title = to_fuzzy_arel(:title, query)
-
-      where(title)
+      fuzzy_search(query, [:title])
     end
 
     # Searches for records with a matching title or description.
@@ -134,10 +132,7 @@ module Issuable
     #
     # Returns an ActiveRecord::Relation.
     def full_search(query)
-      title = to_fuzzy_arel(:title, query)
-      description = to_fuzzy_arel(:description, query)
-
-      where(title&.or(description))
+      fuzzy_search(query, [:title, :description])
     end
 
     def sort(method, excluded_labels: [])

app/models/email.rb

 class Email < ActiveRecord::Base
   include Sortable
+  include Gitlab::SQL::Pattern
 
   belongs_to :user
 

app/models/group.rb

@@ -68,20 +68,6 @@ class Group < Namespace
       Gitlab::Database.postgresql?
     end
 
-    # Searches for groups matching the given query.
-    #
-    # This method uses ILIKE on PostgreSQL and LIKE on MySQL.
-    #
-    # query - The search query as a String
-    #
-    # Returns an ActiveRecord::Relation.
-    def search(query)
-      table   = Namespace.arel_table
-      pattern = "%#{query}%"
-
-      where(table[:name].matches(pattern).or(table[:path].matches(pattern)))
-    end
-
     def sort(method)
       if method == 'storage_size_desc'
         # storage_size is a virtual column so we need to

app/models/merge_request.rb

@@ -292,9 +292,9 @@ class MergeRequest < ActiveRecord::Base
     if persisted?
       merge_request_diff.commit_shas
     elsif compare_commits
-      compare_commits.reverse.map(&:sha)
+      compare_commits.to_a.reverse.map(&:sha)
     else
-      []
+      Array(diff_head_sha)
     end
   end
 
@@ -373,16 +373,28 @@ class MergeRequest < ActiveRecord::Base
   # We use these attributes to force these to the intended values.
   attr_writer :target_branch_sha, :source_branch_sha
 
+  def source_branch_ref
+    return @source_branch_sha if @source_branch_sha
+    return unless source_branch
+
+    Gitlab::Git::BRANCH_REF_PREFIX + source_branch
+  end
+
+  def target_branch_ref
+    return @target_branch_sha if @target_branch_sha
+    return unless target_branch
+
+    Gitlab::Git::BRANCH_REF_PREFIX + target_branch
+  end
+
   def source_branch_head
     return unless source_project
 
-    source_branch_ref = @source_branch_sha || source_branch
     source_project.repository.commit(source_branch_ref) if source_branch_ref
   end
 
   def target_branch_head
-    target_branch_ref = @target_branch_sha || target_branch
-    target_project.repository.commit(target_branch_ref) if target_branch_ref
+    target_project.repository.commit(target_branch_ref)
   end
 
   def branch_merge_base_commit
@@ -507,7 +519,7 @@ class MergeRequest < ActiveRecord::Base
 
   def merge_request_diff_for(diff_refs_or_sha)
     @merge_request_diffs_by_diff_refs_or_sha ||= Hash.new do |h, diff_refs_or_sha|
-      diffs = merge_request_diffs.viewable.select_without_diff
+      diffs = merge_request_diffs.viewable
       h[diff_refs_or_sha] =
         if diff_refs_or_sha.is_a?(Gitlab::Diff::DiffRefs)
           diffs.find_by_diff_refs(diff_refs_or_sha)
@@ -932,28 +944,18 @@ class MergeRequest < ActiveRecord::Base
   # Note that this could also return SHA from now dangling commits
   #
   def all_commit_shas
-    if persisted?
+    return commit_shas unless persisted?
+
+    diffs_relation = merge_request_diffs
+
     # MySQL doesn't support LIMIT in a subquery.
-      diffs_relation =
-        if Gitlab::Database.postgresql?
-          merge_request_diffs.order(id: :desc).limit(100)
-        else
-          merge_request_diffs
-        end
+    diffs_relation = diffs_relation.recent if Gitlab::Database.postgresql?
 
-      column_shas = MergeRequestDiffCommit
+    MergeRequestDiffCommit
       .where(merge_request_diff: diffs_relation)
       .limit(10_000)
       .pluck('sha')
-
-      serialised_shas = merge_request_diffs.where.not(st_commits: nil).flat_map(&:commit_shas)
-
-      (column_shas + serialised_shas).uniq
-    elsif compare_commits
-      compare_commits.to_a.reverse.map(&:id)
-    else
-      [diff_head_sha]
-    end
+      .uniq
   end
 
   def merge_commit

app/models/merge_request_diff.rb

 class MergeRequestDiff < ActiveRecord::Base
   include Sortable
   include Importable
-  include Gitlab::EncodingHelper
   include ManualInverseAssociation
+  include IgnorableColumn
 
-  # Prevent store of diff if commits amount more then 500
+  # Don't display more than 100 commits at once
   COMMITS_SAFE_SIZE = 100
 
-  # Valid types of serialized diffs allowed by Gitlab::Git::Diff
-  VALID_CLASSES = [Hash, Rugged::Patch, Rugged::Diff::Delta].freeze
+  ignore_column :st_commits,
+                :st_diffs
 
   belongs_to :merge_request
   manual_inverse_association :merge_request, :merge_request_diff
@@ -16,9 +16,6 @@ class MergeRequestDiff < ActiveRecord::Base
   has_many :merge_request_diff_files, -> { order(:merge_request_diff_id, :relative_order) }
   has_many :merge_request_diff_commits, -> { order(:merge_request_diff_id, :relative_order) }
 
-  serialize :st_commits # rubocop:disable Cop/ActiveRecordSerialize
-  serialize :st_diffs # rubocop:disable Cop/ActiveRecordSerialize
-
   state_machine :state, initial: :empty do
     state :collected
     state :overflow
@@ -32,6 +29,8 @@ class MergeRequestDiff < ActiveRecord::Base
 
   scope :viewable, -> { without_state(:empty) }
 
+  scope :recent, -> { order(id: :desc).limit(100) }
+
   # All diff information is collected from repository after object is created.
   # It allows you to override variables like head_commit_sha before getting diff.
   after_create :save_git_content, unless: :importing?
@@ -40,14 +39,6 @@ class MergeRequestDiff < ActiveRecord::Base
     find_by(start_commit_sha: diff_refs.start_sha, head_commit_sha: diff_refs.head_sha, base_commit_sha: diff_refs.base_sha)
   end
 
-  def self.select_without_diff
-    select(column_names - ['st_diffs'])
-  end
-
-  def st_commits
-    super || []
-  end
-
   # Collect information about commits and diff from repository
   # and save it to the database as serialized data
   def save_git_content
@@ -129,12 +120,8 @@ class MergeRequestDiff < ActiveRecord::Base
   end
 
   def commit_shas
-    if st_commits.present?
-      st_commits.map { |commit| commit[:id] }
-    else
     merge_request_diff_commits.map(&:sha)
   end
-  end
 
   def diff_refs=(new_diff_refs)
     self.base_commit_sha = new_diff_refs&.base_sha
@@ -208,34 +195,11 @@ class MergeRequestDiff < ActiveRecord::Base
   end
 
   def commits_count
-    if st_commits.present?
-      st_commits.size
-    else
     merge_request_diff_commits.size
   end
-  end
-
-  def utf8_st_diffs
-    return [] if st_diffs.blank?
-
-    st_diffs.map do |diff|
-      diff.each do |k, v|
-        diff[k] = encode_utf8(v) if v.respond_to?(:encoding)
-      end
-    end
-  end
 
   private
 
-  # Old GitLab implementations may have generated diffs as ["--broken-diff"].
-  # Avoid an error 500 by ignoring bad elements. See:
-  # https://gitlab.com/gitlab-org/gitlab-ce/issues/20776
-  def valid_raw_diff?(raw)
-    return false unless raw.respond_to?(:each)
-
-    raw.any? { |element| VALID_CLASSES.include?(element.class) }
-  end
-
   def create_merge_request_diff_files(diffs)
     rows = diffs.map.with_index do |diff, index|
       diff_hash = diff.to_hash.merge(
@@ -259,9 +223,7 @@ class MergeRequestDiff < ActiveRecord::Base
   end
 
   def load_diffs(options)
-    return Gitlab::Git::DiffCollection.new([]) unless diffs_from_database
-
-    raw = diffs_from_database
+    raw = merge_request_diff_files.map(&:to_hash)
 
     if paths = options[:paths]
       raw = raw.select do |diff|
@@ -272,22 +234,8 @@ class MergeRequestDiff < ActiveRecord::Base
     Gitlab::Git::DiffCollection.new(raw, options)
   end
 
-  def diffs_from_database
-    return @diffs_from_database if defined?(@diffs_from_database)
-
-    @diffs_from_database =
-      if st_diffs.present?
-        if valid_raw_diff?(st_diffs)
-          st_diffs
-        end
-      elsif merge_request_diff_files.present?
-        merge_request_diff_files.map(&:to_hash)
-      end
-  end
-
   def load_commits
-    commits = st_commits.presence || merge_request_diff_commits
-    commits = commits.map { |commit| Commit.from_hash(commit.to_hash, project) }
+    commits = merge_request_diff_commits.map { |commit| Commit.from_hash(commit.to_hash, project) }
 
     CommitCollection
       .new(merge_request.source_project, commits, merge_request.source_branch)

app/models/milestone.rb

@@ -14,6 +14,7 @@ class Milestone < ActiveRecord::Base
   include StripAttribute
   include Elastic::MilestonesSearch
   include Milestoneish
+  include Gitlab::SQL::Pattern
 
   include ::EE::Milestone
 
@@ -77,10 +78,7 @@ class Milestone < ActiveRecord::Base
     #
     # Returns an ActiveRecord::Relation.
     def search(query)
-      t = arel_table
-      pattern = "%#{query}%"
-
-      where(t[:title].matches(pattern).or(t[:description].matches(pattern)))
+      fuzzy_search(query, [:title, :description])
     end
 
     def filter_by_state(milestones, state)

app/models/namespace.rb

@@ -10,6 +10,7 @@ class Namespace < ActiveRecord::Base
   include Routable
   include AfterCommitQueue
   include Storage::LegacyNamespace
+  include Gitlab::SQL::Pattern
 
   # Prevent users from creating unreasonably deep level of nesting.
   # The number 20 was taken based on maximum nesting level of
@@ -87,10 +88,7 @@ class Namespace < ActiveRecord::Base
     #
     # Returns an ActiveRecord::Relation
     def search(query)
-      t = arel_table
-      pattern = "%#{query}%"
-
-      where(t[:name].matches(pattern).or(t[:path].matches(pattern)))
+      fuzzy_search(query, [:name, :path])
     end
 
     def clean_path(path)

app/models/note.rb

@@ -17,6 +17,7 @@ class Note < ActiveRecord::Base
   include ResolvableNote
   include IgnorableColumn
   include Editable
+  include Gitlab::SQL::Pattern
 
   module SpecialRole
     FIRST_TIME_CONTRIBUTOR = :first_time_contributor
@@ -171,6 +172,10 @@ class Note < ActiveRecord::Base
     def has_special_role?(role, note)
       note.special_role == role
     end
+
+    def search(query)
+      fuzzy_search(query, [:note])
+    end
   end
 
   def searchable?

app/models/project.rb

@@ -425,17 +425,11 @@ class Project < ActiveRecord::Base
     #
     # query - The search query as a String.
     def search(query)
-      pattern = to_pattern(query)
-
-      where(
-        arel_table[:path].matches(pattern)
-          .or(arel_table[:name].matches(pattern))
-          .or(arel_table[:description].matches(pattern))
-      )
+      fuzzy_search(query, [:path, :name, :description])
     end
 
     def search_by_title(query)
-      non_archived.where(arel_table[:name].matches(to_pattern(query)))
+      non_archived.fuzzy_search(query, [:name])
     end
 
     def visibility_levels

app/models/snippet.rb

@@ -10,6 +10,7 @@ class Snippet < ActiveRecord::Base
   include Mentionable
   include Spammable
   include Editable
+  include Gitlab::SQL::Pattern
 
   extend Gitlab::CurrentSettings
 
@@ -136,10 +137,7 @@ class Snippet < ActiveRecord::Base
     #
     # Returns an ActiveRecord::Relation.
     def search(query)
-      t = arel_table
-      pattern = "%#{query}%"
-
-      where(t[:title].matches(pattern).or(t[:file_name].matches(pattern)))
+      fuzzy_search(query, [:title, :file_name])
     end
 
     # Searches for snippets with matching content.
@@ -150,10 +148,7 @@ class Snippet < ActiveRecord::Base
     #
     # Returns an ActiveRecord::Relation.
     def search_code(query)
-      table   = Snippet.arel_table
-      pattern = "%#{query}%"
-
-      where(table[:content].matches(pattern))
+      fuzzy_search(query, [:content])
     end
   end
 end

app/models/user.rb

@@ -327,9 +327,6 @@ class User < ActiveRecord::Base
     #
     # Returns an ActiveRecord::Relation.
     def search(query)
-      table   = arel_table
-      pattern = User.to_pattern(query)
-
       order = <<~SQL
         CASE
           WHEN users.name = %{query} THEN 0
@@ -339,11 +336,8 @@ class User < ActiveRecord::Base
         END
       SQL
 
-      where(
-        table[:name].matches(pattern)
-          .or(table[:email].matches(pattern))
-          .or(table[:username].matches(pattern))
-      ).reorder(order % { query: ActiveRecord::Base.connection.quote(query) }, :name)
+      fuzzy_search(query, [:name, :email, :username])
+        .reorder(order % { query: ActiveRecord::Base.connection.quote(query) }, :name)
     end
 
     # searches user by given pattern
@@ -351,16 +345,16 @@ class User < ActiveRecord::Base
     # This method uses ILIKE on PostgreSQL and LIKE on MySQL.
 
     def search_with_secondary_emails(query)
-      table = arel_table
       email_table = Email.arel_table
-      pattern = "%#{query}%"
-      matched_by_emails_user_ids = email_table.project(email_table[:user_id]).where(email_table[:email].matches(pattern))
+      matched_by_emails_user_ids = email_table
+        .project(email_table[:user_id])
+        .where(Email.fuzzy_arel_match(:email, query))
 
       where(
-        table[:name].matches(pattern)
-          .or(table[:email].matches(pattern))
-          .or(table[:username].matches(pattern))
-          .or(table[:id].in(matched_by_emails_user_ids))
+        fuzzy_arel_match(:name, query)
+          .or(fuzzy_arel_match(:email, query))
+          .or(fuzzy_arel_match(:username, query))
+          .or(arel_table[:id].in(matched_by_emails_user_ids))
       )
     end
 

app/services/compare_service.rb

 require 'securerandom'
 
-# Compare 2 branches for one repo or between repositories
+# Compare 2 refs for one repo or between repositories
 # and return Gitlab::Git::Compare object that responds to commits and diffs
 class CompareService
-  attr_reader :start_project, :start_branch_name
+  attr_reader :start_project, :start_ref_name
 
-  def initialize(new_start_project, new_start_branch_name)
+  def initialize(new_start_project, new_start_ref_name)
     @start_project = new_start_project
-    @start_branch_name = new_start_branch_name
+    @start_ref_name = new_start_ref_name
   end
 
-  def execute(target_project, target_branch, straight: false)
-    raw_compare = target_project.repository.compare_source_branch(target_branch, start_project.repository, start_branch_name, straight: straight)
+  def execute(target_project, target_ref, straight: false)
+    raw_compare = target_project.repository.compare_source_branch(target_ref, start_project.repository, start_ref_name, straight: straight)
 
     Compare.new(raw_compare, target_project, straight: straight) if raw_compare
   end

app/services/merge_requests/build_service.rb

@@ -22,7 +22,17 @@ module MergeRequests
 
     attr_accessor :merge_request
 
-    delegate :target_branch, :source_branch, :source_project, :target_project, :compare_commits, :wip_title, :description, :errors, to: :merge_request
+    delegate :target_branch,
+             :target_branch_ref,
+             :target_project,
+             :source_branch,
+             :source_branch_ref,
+             :source_project,
+             :compare_commits,
+             :wip_title,
+             :description,
+             :errors,
+             to: :merge_request
 
     def find_source_project
       return source_project if source_project.present? && can?(current_user, :read_project, source_project)
@@ -58,10 +68,10 @@ module MergeRequests
     def compare_branches
       compare = CompareService.new(
         source_project,
-        source_branch
+        source_branch_ref
       ).execute(
         target_project,
-        target_branch
+        target_branch_ref
       )
 
       if compare

app/services/projects/update_service.rb

@@ -51,13 +51,6 @@ module Projects
       params.except(:default_branch, :run_auto_devops_pipeline_explicit, :run_auto_devops_pipeline_implicit)
     end
 
-    def changing_storage_size?
-      new_repository_storage = params[:repository_storage]
-
-      new_repository_storage && project.repository.exists? &&
-        can?(current_user, :change_repository_storage, project)
-    end
-
     def renaming_project_with_container_registry_tags?
       new_path = params[:path]
 

app/views/events/_event.atom.builder

@@ -5,7 +5,12 @@ xml.entry do
   xml.link    href: event_feed_url(event)
   xml.title   truncate(event_feed_title(event), length: 80)
   xml.updated event.updated_at.xmlschema
-  xml.media   :thumbnail, width: "40", height: "40", url: image_url(avatar_icon(event.author_email))
+
+  # We're deliberately re-using "event.author" here since this data is
+  # eager-loaded. This allows us to re-use the user object's Email address,
+  # instead of having to run additional queries to figure out what Email to use
+  # for the avatar.
+  xml.media   :thumbnail, width: "40", height: "40", url: image_url(avatar_icon(event.author))
 
   xml.author do
     xml.username event.author_username

changelogs/unreleased/15588-fix-empty-dropdown-on-create-new-pipeline-in-case-of-validation-errors.yml

+---
+title: Initializes the branches dropdown when the 'Start new pipeline' failed due to validation errors
+merge_request: 15588
+author: Christiaan Van den Poel
+type: fixed

changelogs/unreleased/39827-fix-projects-dropdown-overflow.yml

+---
+title: Fix item name and namespace text overflow in Projects dropdown
+merge_request: 15451
+author:
+type: fixed

changelogs/unreleased/40373-fix-issue-note-submit-disabled-on-paste.yml

+---
+title: Fix Issue comment submit button being disabled when pasting content from another
+  GFM note
+merge_request: 15530
+author:
+type: fixed

changelogs/unreleased/40530-merge-request-generates-wrong-diff-when-branch-and-tag-have-the-same-name.yml

+---
+title: Fix merge requests where the source or target branch name matches a tag name
+merge_request: 15591
+author:
+type: fixed

changelogs/unreleased/bvl-fork-networks-for-deleted-projects.yml

+---
+title: Create a fork network for forks with a deleted source
+merge_request: 15595
+author:
+type: fixed

changelogs/unreleased/default-values-for-mr-states.yml

+---
+title: Fix defaults for MR states and merge statuses
+merge_request:
+author:
+type: fixed

changelogs/unreleased/dm-search-pattern.yml

+---
+title: Use fuzzy search with minimum length of 3 characters where appropriate
+merge_request:
+author:
+type: performance

changelogs/unreleased/events-atom-feed-author-query.yml

+---
+title: Reuse authors when rendering event Atom feeds
+merge_request:
+author:
+type: performance

db/migrate/20171121135738_clean_up_from_merge_request_diffs_and_commits.rb

+class CleanUpFromMergeRequestDiffsAndCommits < ActiveRecord::Migration
+  include Gitlab::Database::MigrationHelpers
+
+  DOWNTIME = false
+
+  class MergeRequestDiff < ActiveRecord::Base
+    self.table_name = 'merge_request_diffs'
+
+    include ::EachBatch
+  end
+
+  disable_ddl_transaction!
+
+  def up
+    Gitlab::BackgroundMigration.steal('DeserializeMergeRequestDiffsAndCommits')
+
+    # The literal '--- []\n' value is created by the import process and treated
+    # as null by the application, so we can ignore those - even if we were
+    # migrating, it wouldn't create any rows.
+    literal_prefix = Gitlab::Database.postgresql? ? 'E' : ''
+    non_empty = "
+      (st_commits IS NOT NULL AND st_commits != #{literal_prefix}'--- []\n')
+      OR
+      (st_diffs IS NOT NULL AND st_diffs != #{literal_prefix}'--- []\n')
+    ".squish
+
+    MergeRequestDiff.where(non_empty).each_batch(of: 500) do |relation, index|
+      range = relation.pluck('MIN(id)', 'MAX(id)').first
+
+      Gitlab::BackgroundMigration::DeserializeMergeRequestDiffsAndCommits.new.perform(*range)
+    end
+  end
+
+  def down
+  end
+end

db/migrate/20171124125042_add_default_values_to_merge_request_states.rb

+# See http://doc.gitlab.com/ce/development/migration_style_guide.html
+# for more information on how to write migrations for GitLab.
+
+class AddDefaultValuesToMergeRequestStates < ActiveRecord::Migration
+  include Gitlab::Database::MigrationHelpers
+
+  # Set this constant to true if this migration requires downtime.
+  DOWNTIME = false
+
+  def up
+    change_column_default :merge_requests, :state, :opened
+    change_column_default :merge_requests, :merge_status, :unchecked
+  end
+
+  def down
+    change_column_default :merge_requests, :state, nil
+    change_column_default :merge_requests, :merge_status, nil
+  end
+end

db/migrate/20171124125748_populate_missing_merge_request_statuses.rb

+# See http://doc.gitlab.com/ce/development/migration_style_guide.html
+# for more information on how to write migrations for GitLab.
+
+class PopulateMissingMergeRequestStatuses < ActiveRecord::Migration
+  include Gitlab::Database::MigrationHelpers
+
+  # Set this constant to true if this migration requires downtime.
+  DOWNTIME = false
+
+  disable_ddl_transaction!
+
+  class MergeRequest < ActiveRecord::Base
+    include EachBatch
+
+    self.table_name = 'merge_requests'
+  end
+
+  def up
+    say 'Populating missing merge_requests.state values'
+
+    # GitLab.com has no rows where "state" is NULL, and technically this should
+    # never happen. However it doesn't hurt to be 100% certain.
+    MergeRequest.where(state: nil).each_batch do |batch|
+      batch.update_all(state: 'opened')
+    end
+
+    say 'Populating missing merge_requests.merge_status values. ' \
+      'This will take a few minutes...'
+
+    # GitLab.com has 66 880 rows where "merge_status" is NULL, dating back all
+    # the way to 2011.
+    MergeRequest.where(merge_status: nil).each_batch(of: 10_000) do |batch|
+      batch.update_all(merge_status: 'unchecked')
+
+      # We want to give PostgreSQL some time to vacuum any dead tuples. In
+      # production we see it takes roughly 1 minute for a vacuuming run to clear
+      # out 10-20k dead tuples, so we'll wait for 90 seconds between every
+      # batch.
+      sleep(90) if sleep?
+    end
+  end
+
+  def down
+    # Reverting this makes no sense.
+  end
+
+  def sleep?
+    Rails.env.staging? || Rails.env.production?
+  end
+end

db/migrate/20171124132536_make_merge_request_statuses_not_null.rb

+# See http://doc.gitlab.com/ce/development/migration_style_guide.html
+# for more information on how to write migrations for GitLab.
+
+class MakeMergeRequestStatusesNotNull < ActiveRecord::Migration
+  include Gitlab::Database::MigrationHelpers
+
+  # Set this constant to true if this migration requires downtime.
+  DOWNTIME = false
+
+  def change
+    change_column_null :merge_requests, :state, false
+    change_column_null :merge_requests, :merge_status, false
+  end
+end

db/migrate/limits_to_mysql.rb

@@ -3,8 +3,19 @@ class LimitsToMysql < ActiveRecord::Migration
   def up
     return unless ActiveRecord::Base.configurations[Rails.env]['adapter'] =~ /^mysql/
 
+    # These columns were removed in 10.3, but this is called from two places:
+    # 1. A migration run after they were added, but before they were removed.
+    # 2. A rake task which can be run at any time.
+    #
+    # Because of item 2, we need these checks.
+    if column_exists?(:merge_request_diffs, :st_commits)
       change_column :merge_request_diffs, :st_commits, :text, limit: 2147483647
+    end
+
+    if column_exists?(:merge_request_diffs, :st_diffs)
       change_column :merge_request_diffs, :st_diffs, :text, limit: 2147483647
+    end
+
     change_column :snippets, :content, :text, limit: 2147483647
     change_column :notes, :st_diff, :text, limit: 2147483647
   end

db/post_migrate/20171121160421_remove_merge_request_diff_st_commits_and_st_diffs.rb

+class RemoveMergeRequestDiffStCommitsAndStDiffs < ActiveRecord::Migration
+  include Gitlab::Database::MigrationHelpers
+
+  DOWNTIME = false
+
+  def change
+    remove_column :merge_request_diffs, :st_commits, :text
+    remove_column :merge_request_diffs, :st_diffs, :text
+  end
+end

db/post_migrate/20171124095655_add_index_on_merge_request_diffs_merge_request_id_and_id.rb

+class AddIndexOnMergeRequestDiffsMergeRequestIdAndId < ActiveRecord::Migration
+  include Gitlab::Database::MigrationHelpers
+
+  DOWNTIME = false
+
+  disable_ddl_transaction!
+
+  def up
+    add_concurrent_index(:merge_request_diffs, [:merge_request_id, :id])
+  end
+
+  def down
+    if index_exists?(:merge_request_diffs, [:merge_request_id, :id])
+      remove_concurrent_index(:merge_request_diffs, [:merge_request_id, :id])
+    end
+  end
+end

db/post_migrate/20171124100152_remove_index_on_merge_request_diffs_merge_request_diff_id.rb

+class RemoveIndexOnMergeRequestDiffsMergeRequestDiffId < ActiveRecord::Migration
+  include Gitlab::Database::MigrationHelpers
+
+  DOWNTIME = false
+
+  disable_ddl_transaction!
+
+  def up
+    if index_exists?(:merge_request_diffs, :merge_request_id)
+      remove_concurrent_index(:merge_request_diffs, :merge_request_id)
+    end
+  end
+
+  def down
+    add_concurrent_index(:merge_request_diffs, :merge_request_id)
+  end
+end

db/post_migrate/20171124150326_reschedule_fork_network_creation.rb

+class RescheduleForkNetworkCreation < ActiveRecord::Migration
+  include Gitlab::Database::MigrationHelpers
+
+  DOWNTIME = false
+
+  MIGRATION = 'PopulateForkNetworksRange'.freeze
+  BATCH_SIZE = 100
+  DELAY_INTERVAL = 15.seconds
+
+  disable_ddl_transaction!
+
+  class ForkedProjectLink < ActiveRecord::Base
+    include EachBatch
+
+    self.table_name = 'forked_project_links'
+  end
+
+  def up
+    say 'Populating the `fork_networks` based on existing `forked_project_links`'
+
+    queue_background_migration_jobs_by_range_at_intervals(ForkedProjectLink, MIGRATION, DELAY_INTERVAL, batch_size: BATCH_SIZE)
+  end
+
+  def down
+    # nothing
+  end
+end

db/schema.rb

@@ -1355,8 +1355,6 @@ ActiveRecord::Schema.define(version: 20171124165823) do
 
   create_table "merge_request_diffs", force: :cascade do |t|
     t.string "state"
-    t.text "st_commits"
-    t.text "st_diffs"
     t.integer "merge_request_id", null: false
     t.datetime "created_at"
     t.datetime "updated_at"
@@ -1366,7 +1364,7 @@ ActiveRecord::Schema.define(version: 20171124165823) do
     t.string "start_commit_sha"
   end
 
-  add_index "merge_request_diffs", ["merge_request_id"], name: "index_merge_request_diffs_on_merge_request_id", using: :btree
+  add_index "merge_request_diffs", ["merge_request_id", "id"], name: "index_merge_request_diffs_on_merge_request_id_and_id", using: :btree
 
   create_table "merge_request_metrics", force: :cascade do |t|
     t.integer "merge_request_id", null: false
@@ -1393,8 +1391,8 @@ ActiveRecord::Schema.define(version: 20171124165823) do
     t.datetime "created_at"
     t.datetime "updated_at"
     t.integer "milestone_id"
-    t.string "state"
-    t.string "merge_status"
+    t.string "state", default: "opened", null: false
+    t.string "merge_status", default: "unchecked", null: false
     t.integer "target_project_id", null: false
     t.integer "iid"
     t.text "description"

doc/administration/troubleshooting/sidekiq.md

@@ -11,7 +11,7 @@ troubleshooting steps that will help you diagnose the bottleneck.
 debug steps with GitLab Support so the backtraces can be analyzed by our team.
 It may reveal a bug or necessary improvement in GitLab.
 
-> **Note:** In any of the backtraces, be weary of suspecting cases where every
+> **Note:** In any of the backtraces, be wary of suspecting cases where every
   thread appears to be waiting in the database, Redis, or waiting to acquire
   a mutex. This **may** mean there's contention in the database, for example,
   but look for one thread that is different than the rest. This other thread

doc/development/rake_tasks.md

@@ -163,7 +163,7 @@ Starting a project from a template needs this project to be exported. On a
 up to date master branch with run:
 
 ```
-gdk run db
+gdk run
 # In a new terminal window
 bundle exec rake gitlab:update_project_templates
 git checkout -b update-project-templates

doc/development/what_requires_downtime.md

@@ -37,7 +37,7 @@ when using the migration helper method
 `Gitlab::Database::MigrationHelpers#add_column_with_default`. This method works
 similar to `add_column` except it updates existing rows in batches without
 blocking access to the table being modified. See ["Adding Columns With Default
-Values"](migration_style_guide.html#adding-columns-with-default-values) for more
+Values"](migration_style_guide.md#adding-columns-with-default-values) for more
 information on how to use this method.
 
 ## Dropping Columns

doc/user/project/integrations/webhooks.md

@@ -756,8 +756,6 @@ X-Gitlab-Event: Merge Request Hook
     "title": "MS-Viewport",
     "created_at": "2013-12-03T17:23:34Z",
     "updated_at": "2013-12-03T17:23:34Z",
-    "st_commits": null,
-    "st_diffs": null,
     "milestone_id": null,
     "state": "opened",
     "merge_status": "unchecked",

doc/user/project/settings/import_export.md

@@ -30,7 +30,8 @@ with all their related data and be moved into a new GitLab instance.
 
 | GitLab version   | Import/Export version |
 | ---------------- | --------------------- |
-| 10.0 to current  | 0.2.0                 |
+| 10.3 to current  | 0.2.1                 |
+| 10.0             | 0.2.0                 |
 | 9.4.0            | 0.1.8                 |
 | 9.2.0            | 0.1.7                 |
 | 8.17.0           | 0.1.6                 |

ee/app/services/ee/projects/update_service.rb

@@ -17,6 +17,13 @@ module EE
         result
       end
 
+      def changing_storage_size?
+        new_repository_storage = params[:repository_storage]
+
+        new_repository_storage && project.repository.exists? &&
+          can?(current_user, :change_repository_storage, project)
+      end
+
       private
 
       def log_audit_events

lib/api/helpers/internal_helpers.rb

@@ -2,8 +2,8 @@ module API
   module Helpers
     module InternalHelpers
       SSH_GITALY_FEATURES = {
-        'git-receive-pack' => :ssh_receive_pack,
-        'git-upload-pack' => :ssh_upload_pack
+        'git-receive-pack' => [:ssh_receive_pack, Gitlab::GitalyClient::MigrationStatus::OPT_IN],
+        'git-upload-pack' => [:ssh_upload_pack, Gitlab::GitalyClient::MigrationStatus::OPT_OUT]
       }.freeze
 
       def wiki?
@@ -102,8 +102,8 @@ module API
 
       # Return the Gitaly Address if it is enabled
       def gitaly_payload(action)
-        feature = SSH_GITALY_FEATURES[action]
-        return unless feature && Gitlab::GitalyClient.feature_enabled?(feature)
+        feature, status = SSH_GITALY_FEATURES[action]
+        return unless feature && Gitlab::GitalyClient.feature_enabled?(feature, status: status)
 
         {
           repository: repository.gitaly_repository,

lib/gitlab/background_migration/populate_fork_networks_range.rb

 # frozen_string_literal: true
-# rubocop:disable Metrics/MethodLength
-# rubocop:disable Metrics/LineLength
-# rubocop:disable Style/Documentation
 
 module Gitlab
   module BackgroundMigration
+    # This background migration is going to create all `fork_networks` and
+    # the `fork_network_members` for the roots of fork networks based on the
+    # existing `forked_project_links`.
+    #
+    # When the source of a fork is deleted, we will create the fork with the
+    # target project as the root. This way, when there are forks of the target
+    # project, they will be joined into the same fork network.
+    #
+    # When the `fork_networks` and memberships for the root projects are created
+    # the `CreateForkNetworkMembershipsRange` migration is scheduled. This
+    # migration will create the memberships for all remaining forks-of-forks
     class PopulateForkNetworksRange
       def perform(start_id, end_id)
-        log("Creating fork networks for forked project links: #{start_id} - #{end_id}")
+        create_fork_networks_for_existing_projects(start_id, end_id)
+        create_fork_networks_for_missing_projects(start_id, end_id)
+        create_fork_networks_memberships_for_root_projects(start_id, end_id)
 
+        delay = BackgroundMigration::CreateForkNetworkMembershipsRange::RESCHEDULE_DELAY # rubocop:disable Metrics/LineLength
+        BackgroundMigrationWorker.perform_in(
+          delay, "CreateForkNetworkMembershipsRange", [start_id, end_id]
+        )
+      end
+
+      def create_fork_networks_for_existing_projects(start_id, end_id)
+        log("Creating fork networks: #{start_id} - #{end_id}")
         ActiveRecord::Base.connection.execute <<~INSERT_NETWORKS
         INSERT INTO fork_networks (root_project_id)
           SELECT DISTINCT forked_project_links.forked_from_project_id
 
           FROM forked_project_links
 
+          -- Exclude the forks that are not the first level fork of a project
           WHERE NOT EXISTS (
             SELECT true
             FROM forked_project_links inner_links
             WHERE inner_links.forked_to_project_id = forked_project_links.forked_from_project_id
           )
+
+          /* Exclude the ones that are already created, in case the fork network
+             was already created for another fork of the project.
+          */
           AND NOT EXISTS (
             SELECT true
             FROM fork_networks
             WHERE forked_project_links.forked_from_project_id = fork_networks.root_project_id
           )
+
+          -- Only create a fork network for a root project that still exists
           AND EXISTS (
             SELECT true
             FROM projects
@@ -32,7 +57,45 @@ module Gitlab
           )
           AND forked_project_links.id BETWEEN #{start_id} AND #{end_id}
         INSERT_NETWORKS
+      end
+
+      def create_fork_networks_for_missing_projects(start_id, end_id)
+        log("Creating fork networks with missing root: #{start_id} - #{end_id}")
+        ActiveRecord::Base.connection.execute <<~INSERT_NETWORKS
+        INSERT INTO fork_networks (root_project_id)
+          SELECT DISTINCT forked_project_links.forked_to_project_id
+
+          FROM forked_project_links
+
+          -- Exclude forks that are not the root forks
+          WHERE NOT EXISTS (
+            SELECT true
+            FROM forked_project_links inner_links
+            WHERE inner_links.forked_to_project_id = forked_project_links.forked_from_project_id
+          )
+
+          /* Exclude the ones that are already created, in case this migration is
+             re-run
+          */
+          AND NOT EXISTS (
+            SELECT true
+            FROM fork_networks
+            WHERE forked_project_links.forked_to_project_id = fork_networks.root_project_id
+          )
+
+          /* Exclude projects for which the project still exists, those are
+             Processed in the previous step of this migration
+          */
+          AND NOT EXISTS (
+            SELECT true
+            FROM projects
+            WHERE projects.id = forked_project_links.forked_from_project_id
+          )
+          AND forked_project_links.id BETWEEN #{start_id} AND #{end_id}
+        INSERT_NETWORKS
+      end
 
+      def create_fork_networks_memberships_for_root_projects(start_id, end_id)
         log("Creating memberships for root projects: #{start_id} - #{end_id}")
 
         ActiveRecord::Base.connection.execute <<~INSERT_ROOT
@@ -41,8 +104,12 @@ module Gitlab
 
           FROM fork_networks
 
+          /* Joining both on forked_from- and forked_to- so we could create the
+             memberships for forks for which the source was deleted
+          */
           INNER JOIN forked_project_links
               ON forked_project_links.forked_from_project_id = fork_networks.root_project_id
+              OR forked_project_links.forked_to_project_id = fork_networks.root_project_id
 
           WHERE NOT EXISTS (
             SELECT true
@@ -51,9 +118,6 @@ module Gitlab
           )
           AND forked_project_links.id BETWEEN #{start_id} AND #{end_id}
         INSERT_ROOT
-
-        delay = BackgroundMigration::CreateForkNetworkMembershipsRange::RESCHEDULE_DELAY
-        BackgroundMigrationWorker.perform_in(delay, "CreateForkNetworkMembershipsRange", [start_id, end_id])
       end
 
       def log(message)

lib/gitlab/cycle_analytics/plan_event_fetcher.rb

@@ -3,7 +3,6 @@ module Gitlab
     class PlanEventFetcher < BaseEventFetcher
       def initialize(*args)
         @projections = [mr_diff_table[:id],
-                        mr_diff_table[:st_commits],
                         issue_metrics_table[:first_mentioned_in_commit_at]]
 
         super(*args)
@@ -37,12 +36,7 @@ module Gitlab
       def first_time_reference_commit(event)
         return nil unless event && merge_request_diff_commits
 
-        commits =
-          if event['st_commits'].present?
-            YAML.load(event['st_commits'])
-          else
-            merge_request_diff_commits[event['id'].to_i]
-          end
+        commits = merge_request_diff_commits[event['id'].to_i]
 
         return nil if commits.blank?
 

lib/gitlab/git/repository.rb

@@ -1047,9 +1047,15 @@ module Gitlab
       end
 
       def with_repo_tmp_commit(start_repository, start_branch_name, sha)
+        source_ref = start_branch_name
+
+        unless Gitlab::Git.branch_ref?(source_ref)
+          source_ref = "#{Gitlab::Git::BRANCH_REF_PREFIX}#{source_ref}"
+        end
+
         tmp_ref = fetch_ref(
           start_repository,
-          source_ref: "#{Gitlab::Git::BRANCH_REF_PREFIX}#{start_branch_name}",
+          source_ref: source_ref,
           target_ref: "refs/tmp/#{SecureRandom.hex}"
         )
 

lib/gitlab/gitaly_client.rb

@@ -31,14 +31,38 @@ module Gitlab
     CLIENT_NAME = (Sidekiq.server? ? 'gitlab-sidekiq' : 'gitlab-web').freeze
 
     MUTEX = Mutex.new
-    private_constant :MUTEX
+    METRICS_MUTEX = Mutex.new
+    private_constant :MUTEX, :METRICS_MUTEX
 
     class << self
-      attr_accessor :query_time, :migrate_histogram
+      attr_accessor :query_time
     end
 
     self.query_time = 0
-    self.migrate_histogram = Gitlab::Metrics.histogram(:gitaly_migrate_call_duration, "Gitaly migration call execution timings")
+
+    def self.migrate_histogram
+      @migrate_histogram ||=
+        METRICS_MUTEX.synchronize do
+          # If a thread was blocked on the mutex, the value was set already
+          return @migrate_histogram if @migrate_histogram
+
+          Gitlab::Metrics.histogram(:gitaly_migrate_call_duration_seconds,
+                                    "Gitaly migration call execution timings",
+                                    gitaly_enabled: nil, feature: nil)
+        end
+    end
+
+    def self.gitaly_call_histogram
+      @gitaly_call_histogram ||=
+        METRICS_MUTEX.synchronize do
+          # If a thread was blocked on the mutex, the value was set already
+          return @gitaly_call_histogram if @gitaly_call_histogram
+
+          Gitlab::Metrics.histogram(:gitaly_controller_action_duration_seconds,
+                                    "Gitaly endpoint histogram by controller and action combination",
+                                    Gitlab::Metrics::Transaction::BASE_LABELS.merge(gitaly_service: nil, rpc: nil))
+        end
+    end
 
     def self.stub(name, storage)
       MUTEX.synchronize do
@@ -94,7 +118,7 @@ module Gitlab
     # end
     #
     def self.call(storage, service, rpc, request, remote_storage: nil, timeout: nil)
-      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      start = Gitlab::Metrics::System.monotonic_time
       enforce_gitaly_request_limits(:call)
 
       kwargs = request_kwargs(storage, timeout, remote_storage: remote_storage)
@@ -102,8 +126,19 @@ module Gitlab
 
       stub(service, storage).__send__(rpc, request, kwargs) # rubocop:disable GitlabSecurity/PublicSend
     ensure
-      self.query_time += Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+      duration = Gitlab::Metrics::System.monotonic_time - start
+
+      # Keep track, seperately, for the performance bar
+      self.query_time += duration
+      gitaly_call_histogram.observe(
+        current_transaction_labels.merge(gitaly_service: service.to_s, rpc: rpc.to_s),
+        duration)
+    end
+
+    def self.current_transaction_labels
+      Gitlab::Metrics::Transaction.current&.labels || {}
     end
+    private_class_method :current_transaction_labels
 
     def self.request_kwargs(storage, timeout, remote_storage: nil)
       encoded_token = Base64.strict_encode64(token(storage).to_s)
@@ -193,10 +228,10 @@ module Gitlab
           feature_stack = Thread.current[:gitaly_feature_stack] ||= []
           feature_stack.unshift(feature)
           begin
-            start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            start = Gitlab::Metrics::System.monotonic_time
             yield is_enabled
           ensure
-            total_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+            total_time = Gitlab::Metrics::System.monotonic_time - start
             migrate_histogram.observe({ gitaly_enabled: is_enabled, feature: feature }, total_time)
             feature_stack.shift
             Thread.current[:gitaly_feature_stack] = nil if feature_stack.empty?

lib/gitlab/import_export.rb

@@ -3,7 +3,7 @@ module Gitlab
     extend self
 
     # For every version update, the version history in import_export.md has to be kept up to date.
-    VERSION = '0.2.0'.freeze
+    VERSION = '0.2.1'.freeze
     FILENAME_LIMIT = 50
 
     def export_path(relative_path:)

lib/gitlab/import_export/import_export.yml

@@ -138,8 +138,6 @@ methods:
     - :type
   services:
     - :type
-  merge_request_diff:
-    - :utf8_st_diffs
   merge_request_diff_files:
     - :utf8_diff
   merge_requests:

lib/gitlab/import_export/relation_factory.rb

@@ -58,7 +58,6 @@ module Gitlab
 
       def setup_models
         case @relation_name
-        when :merge_request_diff             then setup_st_diff_commits
         when :merge_request_diff_files       then setup_diff
         when :notes                          then setup_note
         when :project_label, :project_labels then setup_label
@@ -208,13 +207,6 @@ module Gitlab
                                                                                relation_class: relation_class)
       end
 
-      def setup_st_diff_commits
-        @relation_hash['st_diffs'] = @relation_hash.delete('utf8_st_diffs')
-
-        HashUtil.deep_symbolize_array!(@relation_hash['st_diffs'])
-        HashUtil.deep_symbolize_array_with_date!(@relation_hash['st_commits'])
-      end
-
       def setup_diff
         @relation_hash['diff'] = @relation_hash.delete('utf8_diff')
       end

lib/gitlab/sql/pattern.rb

@@ -4,9 +4,15 @@ module Gitlab
       extend ActiveSupport::Concern
 
       MIN_CHARS_FOR_PARTIAL_MATCHING = 3
-      REGEX_QUOTED_WORD = /(?<=^| )"[^"]+"(?= |$)/
+      REGEX_QUOTED_WORD = /(?<=\A| )"[^"]+"(?= |\z)/
 
       class_methods do
+        def fuzzy_search(query, columns)
+          matches = columns.map { |col| fuzzy_arel_match(col, query) }.compact.reduce(:or)
+
+          where(matches)
+        end
+
         def to_pattern(query)
           if partial_matching?(query)
             "%#{sanitize_sql_like(query)}%"
@@ -19,12 +25,19 @@ module Gitlab
           query.length >= MIN_CHARS_FOR_PARTIAL_MATCHING
         end
 
-        def to_fuzzy_arel(column, query)
-          words = select_fuzzy_words(query)
+        def fuzzy_arel_match(column, query)
+          query = query.squish
+          return nil unless query.present?
 
-          matches = words.map { |word| arel_table[column].matches(to_pattern(word)) }
+          words = select_fuzzy_words(query)
 
-          matches.reduce { |result, match| result.and(match) }
+          if words.any?
+            words.map { |word| arel_table[column].matches(to_pattern(word)) }.reduce(:and)
+          else
+            # No words of at least 3 chars, but we can search for an exact
+            # case insensitive match with the query as a whole
+            arel_table[column].matches(sanitize_sql_like(query))
+          end
         end
 
         def select_fuzzy_words(query)
@@ -32,7 +45,7 @@ module Gitlab
 
           query = quoted_words.reduce(query) { |q, quoted_word| q.sub(quoted_word, '') }
 
-          words = query.split(/\s+/)
+          words = query.split
 
           quoted_words.map! { |quoted_word| quoted_word[1..-2] }
 

spec/features/projects/pipelines/pipelines_spec.rb

@@ -500,6 +500,18 @@ describe 'Pipelines', :js do
           end
 
           it { expect(page).to have_content('Missing .gitlab-ci.yml file') }
+          it 'creates a pipeline after first request failed and a valid gitlab-ci.yml file is available when trying again' do
+            click_button project.default_branch
+
+            stub_ci_pipeline_to_return_yaml_file
+
+            page.within '.dropdown-menu' do
+              click_link 'master'
+            end
+
+            expect { click_on 'Create pipeline' }
+              .to change { Ci::Pipeline.count }.by(1)
+          end
         end
       end
     end

spec/javascripts/behaviors/autosize_spec.js

-/* eslint-disable space-before-function-paren, no-var, comma-dangle, no-return-assign, max-len */
-
 import '~/behaviors/autosize';
 
-(function() {
-  describe('Autosize behavior', function() {
-    var load;
-    beforeEach(function() {
-      return setFixtures('<textarea class="js-autosize" style="resize: vertical"></textarea>');
+function load() {
+  $(document).trigger('load');
+}
+
+describe('Autosize behavior', () => {
+  beforeEach(() => {
+    setFixtures('<textarea class="js-autosize" style="resize: vertical"></textarea>');
   });
-    it('does not overwrite the resize property', function() {
+
+  it('does not overwrite the resize property', () => {
     load();
-      return expect($('textarea')).toHaveCss({
-        resize: 'vertical'
-      });
+    expect($('textarea')).toHaveCss({
+      resize: 'vertical',
     });
-    return load = function() {
-      return $(document).trigger('load');
-    };
   });
-}).call(window);
+});

spec/javascripts/projects_dropdown/components/projects_list_item_spec.js

@@ -50,6 +50,18 @@ describe('ProjectsListItemComponent', () => {
         expect(vm.highlightedProjectName).toBe(mockProject.name);
       });
     });
+
+    describe('truncatedNamespace', () => {
+      it('should truncate project name from namespace string', () => {
+        vm.namespace = 'platform / nokia-3310';
+        expect(vm.truncatedNamespace).toBe('platform');
+      });
+
+      it('should truncate namespace string from the middle if it includes more than two groups in path', () => {
+        vm.namespace = 'platform / hardware / broadcom / Wifi Group / Mobile Chipset / nokia-3310';
+        expect(vm.truncatedNamespace).toBe('platform / ... / Mobile Chipset');
+      });
+    });
   });
 
   describe('template', () => {

spec/lib/gitlab/background_migration/deserialize_merge_request_diffs_and_commits_spec.rb

 require 'spec_helper'
 
-describe Gitlab::BackgroundMigration::DeserializeMergeRequestDiffsAndCommits, :truncate do
+describe Gitlab::BackgroundMigration::DeserializeMergeRequestDiffsAndCommits, :truncate, :migration, schema: 20171114162227 do
+  let(:merge_request_diffs) { table(:merge_request_diffs) }
+  let(:merge_requests) { table(:merge_requests) }
+
   describe '#perform' do
-    let(:merge_request) { create(:merge_request) }
-    let(:merge_request_diff) { merge_request.merge_request_diff }
+    let(:project) { create(:project, :repository) }
+    let(:merge_request) { merge_requests.create!(iid: 1, target_project_id: project.id, source_project_id: project.id, target_branch: 'feature', source_branch: 'master').becomes(MergeRequest) }
+    let(:merge_request_diff) { MergeRequest.find(merge_request.id).create_merge_request_diff }
     let(:updated_merge_request_diff) { MergeRequestDiff.find(merge_request_diff.id) }
 
     def diffs_to_hashes(diffs)
@@ -68,7 +72,7 @@ describe Gitlab::BackgroundMigration::DeserializeMergeRequestDiffsAndCommits, :t
       let(:stop_id) { described_class::MergeRequestDiff.maximum(:id) }
 
       before do
-        merge_request.reload_diff(true)
+        merge_request.create_merge_request_diff
 
         convert_to_yaml(start_id, merge_request_diff.commits, diffs_to_hashes(merge_request_diff.merge_request_diff_files))
         convert_to_yaml(stop_id, updated_merge_request_diff.commits, diffs_to_hashes(updated_merge_request_diff.merge_request_diff_files))
@@ -288,7 +292,7 @@ describe Gitlab::BackgroundMigration::DeserializeMergeRequestDiffsAndCommits, :t
 
     context 'when the merge request diffs are Rugged::Patch instances' do
       let(:commits) { merge_request_diff.commits.map(&:to_hash) }
-      let(:first_commit) { merge_request.project.repository.commit(merge_request_diff.head_commit_sha) }
+      let(:first_commit) { project.repository.commit(merge_request_diff.head_commit_sha) }
       let(:expected_commits) { commits }
       let(:diffs) { first_commit.rugged_diff_from_parent.patches }
       let(:expected_diffs) { [] }
@@ -298,7 +302,7 @@ describe Gitlab::BackgroundMigration::DeserializeMergeRequestDiffsAndCommits, :t
 
     context 'when the merge request diffs are Rugged::Diff::Delta instances' do
       let(:commits) { merge_request_diff.commits.map(&:to_hash) }
-      let(:first_commit) { merge_request.project.repository.commit(merge_request_diff.head_commit_sha) }
+      let(:first_commit) { project.repository.commit(merge_request_diff.head_commit_sha) }
       let(:expected_commits) { commits }
       let(:diffs) { first_commit.rugged_diff_from_parent.deltas }
       let(:expected_diffs) { [] }

spec/lib/gitlab/background_migration/populate_fork_networks_range_spec.rb

@@ -62,12 +62,15 @@ describe Gitlab::BackgroundMigration::PopulateForkNetworksRange, :migration, sch
     expect(base2_membership).not_to be_nil
   end
 
-  it 'skips links that had their source project deleted' do
-    forked_project_links.create(id: 6, forked_from_project_id: 99999, forked_to_project_id: create(:project).id)
+  it 'creates a fork network for the fork of which the source was deleted' do
+    fork = create(:project)
+    forked_project_links.create(id: 6, forked_from_project_id: 99999, forked_to_project_id: fork.id)
 
     migration.perform(5, 8)
 
     expect(fork_networks.find_by(root_project_id: 99999)).to be_nil
+    expect(fork_networks.find_by(root_project_id: fork.id)).not_to be_nil
+    expect(fork_network_members.find_by(project_id: fork.id)).not_to be_nil
   end
 
   it 'schedules a job for inserting memberships for forks-of-forks' do

spec/lib/gitlab/diff/position_tracer_spec.rb

@@ -1771,9 +1771,9 @@ describe Gitlab::Diff::PositionTracer do
 
     describe "merge of target branch" do
       let(:merge_commit) do
-        update_file_again_commit
+        second_create_file_commit
 
-        merge_request = create(:merge_request, source_branch: second_create_file_commit.sha, target_branch: branch_name, source_project: project)
+        merge_request = create(:merge_request, source_branch: second_branch_name, target_branch: branch_name, source_project: project)
 
         repository.merge(current_user, merge_request.diff_head_sha, merge_request, "Merge branches")
 

spec/lib/gitlab/import_export/project_tree_restorer_spec.rb

@@ -95,26 +95,12 @@ describe Gitlab::ImportExport::ProjectTreeRestorer do
         end
       end
 
-      it 'has the correct data for merge request st_diffs' do
-        # makes sure we are renaming the custom method +utf8_st_diffs+ into +st_diffs+
-        # one MergeRequestDiff uses the new format, where st_diffs is expected to be nil
-
-        expect(MergeRequestDiff.where.not(st_diffs: nil).count).to eq(8)
-      end
-
       it 'has the correct data for merge request diff files' do
-        expect(MergeRequestDiffFile.where.not(diff: nil).count).to eq(9)
+        expect(MergeRequestDiffFile.where.not(diff: nil).count).to eq(55)
       end
 
-      it 'has the correct data for merge request diff commits in serialised and table formats' do
-        expect(MergeRequestDiff.where.not(st_commits: nil).count).to eq(7)
-        expect(MergeRequestDiffCommit.count).to eq(6)
-      end
-
-      it 'has the correct time for merge request st_commits' do
-        st_commits = MergeRequestDiff.where.not(st_commits: nil).first.st_commits
-
-        expect(st_commits.first[:committed_date]).to be_kind_of(Time)
+      it 'has the correct data for merge request diff commits' do
+        expect(MergeRequestDiffCommit.count).to eq(77)
       end
 
       it 'has the correct data for merge request latest_merge_request_diff' do

spec/lib/gitlab/import_export/project_tree_saver_spec.rb

@@ -97,10 +97,6 @@ describe Gitlab::ImportExport::ProjectTreeSaver do
         expect(saved_project_json['merge_requests'].first['merge_request_diff']).not_to be_empty
       end
 
-      it 'has merge requests diff st_diffs' do
-        expect(saved_project_json['merge_requests'].first['merge_request_diff']['utf8_st_diffs']).not_to be_nil
-      end
-
       it 'has merge request diff files' do
         expect(saved_project_json['merge_requests'].first['merge_request_diff']['merge_request_diff_files']).not_to be_empty
       end
@@ -176,12 +172,6 @@ describe Gitlab::ImportExport::ProjectTreeSaver do
         expect(saved_project_json['custom_attributes'].count).to eq(2)
       end
 
-      it 'does not complain about non UTF-8 characters in MR diffs' do
-        ActiveRecord::Base.connection.execute("UPDATE merge_request_diffs SET st_diffs = '---\n- :diff: !binary |-\n    LS0tIC9kZXYvbnVsbAorKysgYi9pbWFnZXMvbnVjb3IucGRmCkBAIC0wLDAg\n    KzEsMTY3OSBAQAorJVBERi0xLjUNJeLjz9MNCisxIDAgb2JqDTw8L01ldGFk\n    YXR'")
-
-        expect(project_tree_saver.save).to be true
-      end
-
       it 'does not complain about non UTF-8 characters in MR diff files' do
         ActiveRecord::Base.connection.execute("UPDATE merge_request_diff_files SET diff = '---\n- :diff: !binary |-\n    LS0tIC9kZXYvbnVsbAorKysgYi9pbWFnZXMvbnVjb3IucGRmCkBAIC0wLDAg\n    KzEsMTY3OSBAQAorJVBERi0xLjUNJeLjz9MNCisxIDAgb2JqDTw8L01ldGFk\n    YXR'")
 

spec/lib/gitlab/import_export/safe_model_attributes.yml

@@ -177,7 +177,6 @@ MergeRequest:
 MergeRequestDiff:
 - id
 - state
-- st_commits
 - merge_request_id
 - created_at
 - updated_at

spec/lib/gitlab/sql/pattern_spec.rb

@@ -137,22 +137,22 @@ describe Gitlab::SQL::Pattern do
     end
   end
 
-  describe '.to_fuzzy_arel' do
-    subject(:to_fuzzy_arel) { Issue.to_fuzzy_arel(:title, query) }
+  describe '.fuzzy_arel_match' do
+    subject(:fuzzy_arel_match) { Issue.fuzzy_arel_match(:title, query) }
 
     context 'with a word equal to 3 chars' do
       let(:query) { 'foo' }
 
       it 'returns a single ILIKE condition' do
-        expect(to_fuzzy_arel.to_sql).to match(/title.*I?LIKE '\%foo\%'/)
+        expect(fuzzy_arel_match.to_sql).to match(/title.*I?LIKE '\%foo\%'/)
       end
     end
 
     context 'with a word shorter than 3 chars' do
       let(:query) { 'fo' }
 
-      it 'returns nil' do
-        expect(to_fuzzy_arel).to be_nil
+      it 'returns a single equality condition' do
+        expect(fuzzy_arel_match.to_sql).to match(/title.*I?LIKE 'fo'/)
       end
     end
 
@@ -160,7 +160,23 @@ describe Gitlab::SQL::Pattern do
       let(:query) { 'foo baz' }
 
       it 'returns a joining LIKE condition using a AND' do
-        expect(to_fuzzy_arel.to_sql).to match(/title.+I?LIKE '\%foo\%' AND .*title.*I?LIKE '\%baz\%'/)
+        expect(fuzzy_arel_match.to_sql).to match(/title.+I?LIKE '\%foo\%' AND .*title.*I?LIKE '\%baz\%'/)
+      end
+    end
+
+    context 'with two words both shorter than 3 chars' do
+      let(:query) { 'fo ba' }
+
+      it 'returns a single ILIKE condition' do
+        expect(fuzzy_arel_match.to_sql).to match(/title.*I?LIKE 'fo ba'/)
+      end
+    end
+
+    context 'with two words, one shorter 3 chars' do
+      let(:query) { 'foo ba' }
+
+      it 'returns a single ILIKE condition using the longer word' do
+        expect(fuzzy_arel_match.to_sql).to match(/title.+I?LIKE '\%foo\%'/)
       end
     end
 
@@ -168,7 +184,7 @@ describe Gitlab::SQL::Pattern do
       let(:query) { 'foo "really bar" baz' }
 
       it 'returns a joining LIKE condition using a AND' do
-        expect(to_fuzzy_arel.to_sql).to match(/title.+I?LIKE '\%foo\%' AND .*title.*I?LIKE '\%baz\%' AND .*title.*I?LIKE '\%really bar\%'/)
+        expect(fuzzy_arel_match.to_sql).to match(/title.+I?LIKE '\%foo\%' AND .*title.*I?LIKE '\%baz\%' AND .*title.*I?LIKE '\%really bar\%'/)
       end
     end
   end

spec/models/ci/runner_spec.rb

@@ -473,7 +473,7 @@ describe Ci::Runner do
   end
 
   describe '.search' do
-    let(:runner) { create(:ci_runner, token: '123abc') }
+    let(:runner) { create(:ci_runner, token: '123abc', description: 'test runner') }
 
     it 'returns runners with a matching token' do
       expect(described_class.search(runner.token)).to eq([runner])

spec/models/concerns/issuable_spec.rb

@@ -67,6 +67,7 @@ describe Issuable do
 
   describe ".search" do
     let!(:searchable_issue) { create(:issue, title: "Searchable awesome issue") }
+    let!(:searchable_issue2) { create(:issue, title: 'Aw') }
 
     it 'returns issues with a matching title' do
       expect(issuable_class.search(searchable_issue.title))
@@ -86,8 +87,8 @@ describe Issuable do
       expect(issuable_class.search('searchable issue')).to eq([searchable_issue])
     end
 
-    it 'returns all issues with a query shorter than 3 chars' do
-      expect(issuable_class.search('zz')).to eq(issuable_class.all)
+    it 'returns issues with a matching title for a query shorter than 3 chars' do
+      expect(issuable_class.search(searchable_issue2.title.downcase)).to eq([searchable_issue2])
     end
   end
 
@@ -95,6 +96,7 @@ describe Issuable do
     let!(:searchable_issue) do
       create(:issue, title: "Searchable awesome issue", description: 'Many cute kittens')
     end
+    let!(:searchable_issue2) { create(:issue, title: "Aw", description: "Cu") }
 
     it 'returns issues with a matching title' do
       expect(issuable_class.full_search(searchable_issue.title))
@@ -133,8 +135,8 @@ describe Issuable do
       expect(issuable_class.full_search('many kittens')).to eq([searchable_issue])
     end
 
-    it 'returns all issues with a query shorter than 3 chars' do
-      expect(issuable_class.search('zz')).to eq(issuable_class.all)
+    it 'returns issues with a matching description for a query shorter than 3 chars' do
+      expect(issuable_class.full_search(searchable_issue2.description.downcase)).to eq([searchable_issue2])
     end
   end
 

spec/models/merge_request_diff_spec.rb

 require 'spec_helper'
 
 describe MergeRequestDiff do
+  let(:diff_with_commits) { create(:merge_request).merge_request_diff }
+
   describe 'create new record' do
-    subject { create(:merge_request).merge_request_diff }
+    subject { diff_with_commits }
 
     it { expect(subject).to be_valid }
     it { expect(subject).to be_persisted }
@@ -23,57 +25,41 @@ describe MergeRequestDiff do
   end
 
   describe '#diffs' do
-    let(:mr) { create(:merge_request, :with_diffs) }
-    let(:mr_diff) { mr.merge_request_diff }
-
     context 'when the :ignore_whitespace_change option is set' do
       it 'creates a new compare object instead of loading from the DB' do
-        expect(mr_diff).not_to receive(:load_diffs)
-        expect(mr_diff.compare).to receive(:diffs).and_call_original
+        expect(diff_with_commits).not_to receive(:load_diffs)
+        expect(diff_with_commits.compare).to receive(:diffs).and_call_original
 
-        mr_diff.raw_diffs(ignore_whitespace_change: true)
+        diff_with_commits.raw_diffs(ignore_whitespace_change: true)
       end
     end
 
     context 'when the raw diffs are empty' do
       before do
-        MergeRequestDiffFile.delete_all(merge_request_diff_id: mr_diff.id)
-      end
-
-      it 'returns an empty DiffCollection' do
-        expect(mr_diff.raw_diffs).to be_a(Gitlab::Git::DiffCollection)
-        expect(mr_diff.raw_diffs).to be_empty
-      end
-    end
-
-    context 'when the raw diffs have invalid content' do
-      before do
-        MergeRequestDiffFile.delete_all(merge_request_diff_id: mr_diff.id)
-        mr_diff.update_attributes(st_diffs: ["--broken-diff"])
+        MergeRequestDiffFile.delete_all(merge_request_diff_id: diff_with_commits.id)
       end
 
       it 'returns an empty DiffCollection' do
-        expect(mr_diff.raw_diffs.to_a).to be_empty
-        expect(mr_diff.raw_diffs).to be_a(Gitlab::Git::DiffCollection)
-        expect(mr_diff.raw_diffs).to be_empty
+        expect(diff_with_commits.raw_diffs).to be_a(Gitlab::Git::DiffCollection)
+        expect(diff_with_commits.raw_diffs).to be_empty
       end
     end
 
     context 'when the raw diffs exist' do
       it 'returns the diffs' do
-        expect(mr_diff.raw_diffs).to be_a(Gitlab::Git::DiffCollection)
-        expect(mr_diff.raw_diffs).not_to be_empty
+        expect(diff_with_commits.raw_diffs).to be_a(Gitlab::Git::DiffCollection)
+        expect(diff_with_commits.raw_diffs).not_to be_empty
       end
 
       context 'when the :paths option is set' do
-        let(:diffs) { mr_diff.raw_diffs(paths: ['files/ruby/popen.rb', 'files/ruby/popen.rb']) }
+        let(:diffs) { diff_with_commits.raw_diffs(paths: ['files/ruby/popen.rb', 'files/ruby/popen.rb']) }
 
         it 'only returns diffs that match the (old path, new path) given' do
           expect(diffs.map(&:new_path)).to contain_exactly('files/ruby/popen.rb')
         end
 
         it 'uses the diffs from the DB' do
-          expect(mr_diff).to receive(:load_diffs)
+          expect(diff_with_commits).to receive(:load_diffs)
 
           diffs
         end
@@ -117,51 +103,29 @@ describe MergeRequestDiff do
   end
 
   describe '#commit_shas' do
-    it 'returns all commits SHA using serialized commits' do
-      subject.st_commits = [
-        { id: 'sha1' },
-        { id: 'sha2' }
-      ]
-
-      expect(subject.commit_shas).to eq(%w(sha1 sha2))
+    it 'returns all commit SHAs using commits from the DB' do
+      expect(diff_with_commits.commit_shas).not_to be_empty
+      expect(diff_with_commits.commit_shas).to all(match(/\h{40}/))
     end
   end
 
   describe '#compare_with' do
-    subject { create(:merge_request, source_branch: 'fix').merge_request_diff }
-
     it 'delegates compare to the service' do
       expect(CompareService).to receive(:new).and_call_original
 
-      subject.compare_with(nil)
+      diff_with_commits.compare_with(nil)
     end
 
     it 'uses git diff A..B approach by default' do
-      diffs = subject.compare_with('0b4bc9a49b562e85de7cc9e834518ea6828729b9').diffs
+      diffs = diff_with_commits.compare_with('0b4bc9a49b562e85de7cc9e834518ea6828729b9').diffs
 
-      expect(diffs.size).to eq(3)
+      expect(diffs.size).to eq(21)
     end
   end
 
   describe '#commits_count' do
     it 'returns number of commits using serialized commits' do
-      subject.st_commits = [
-        { id: 'sha1' },
-        { id: 'sha2' }
-      ]
-
-      expect(subject.commits_count).to eq 2
-    end
-  end
-
-  describe '#utf8_st_diffs' do
-    it 'does not raise error when a hash value is in binary' do
-      subject.st_diffs = [
-        { diff: "\0" },
-        { diff: "\x05\x00\x68\x65\x6c\x6c\x6f" }
-      ]
-
-      expect { subject.utf8_st_diffs }.not_to raise_error
+      expect(diff_with_commits.commits_count).to eq(29)
     end
   end
 end

spec/models/merge_request_spec.rb

@@ -260,7 +260,7 @@ describe MergeRequest do
   end
 
   describe '#source_branch_sha' do
-    let(:last_branch_commit) { subject.source_project.repository.commit(subject.source_branch) }
+    let(:last_branch_commit) { subject.source_project.repository.commit(Gitlab::Git::BRANCH_REF_PREFIX + subject.source_branch) }
 
     context 'with diffs' do
       subject { create(:merge_request, :with_diffs) }
@@ -274,6 +274,21 @@ describe MergeRequest do
       it 'returns the sha of the source branch last commit' do
         expect(subject.source_branch_sha).to eq(last_branch_commit.sha)
       end
+
+      context 'when there is a tag name matching the branch name' do
+        let(:tag_name) { subject.source_branch }
+
+        it 'returns the sha of the source branch last commit' do
+          subject.source_project.repository.add_tag(subject.author,
+                                                    tag_name,
+                                                    subject.target_branch_sha,
+                                                    'Add a tag')
+
+          expect(subject.source_branch_sha).to eq(last_branch_commit.sha)
+
+          subject.source_project.repository.rm_tag(subject.author, tag_name)
+        end
+      end
     end
 
     context 'when the merge request is being created' do
@@ -1142,7 +1157,7 @@ describe MergeRequest do
 
       context 'with a completely different branch' do
         before do
-          subject.update(target_branch: 'v1.0.0')
+          subject.update(target_branch: 'csv')
         end
 
         it_behaves_like 'returning all SHA'
@@ -1150,7 +1165,7 @@ describe MergeRequest do
 
       context 'with a branch having no difference' do
         before do
-          subject.update(target_branch: 'v1.1.0')
+          subject.update(target_branch: 'branch-merged')
           subject.reload # make sure commits were not cached
         end
 

spec/models/snippet_spec.rb

@@ -88,7 +88,7 @@ describe Snippet do
   end
 
   describe '.search' do
-    let(:snippet) { create(:snippet) }
+    let(:snippet) { create(:snippet, title: 'test snippet') }
 
     it 'returns snippets with a matching title' do
       expect(described_class.search(snippet.title)).to eq([snippet])

spec/requests/api/internal_spec.rb

@@ -317,9 +317,8 @@ describe API::Internal do
       end
 
       context "git pull" do
-        context "gitaly disabled" do
+        context "gitaly disabled", :disable_gitaly do
           it "has the correct payload" do
-            allow(Gitlab::GitalyClient).to receive(:feature_enabled?).with(:ssh_upload_pack).and_return(false)
             pull(key, project)
 
             expect(response).to have_gitlab_http_status(200)
@@ -333,7 +332,6 @@ describe API::Internal do
 
         context "gitaly enabled" do
           it "has the correct payload" do
-            allow(Gitlab::GitalyClient).to receive(:feature_enabled?).with(:ssh_upload_pack).and_return(true)
             pull(key, project)
 
             expect(response).to have_gitlab_http_status(200)
@@ -352,9 +350,8 @@ describe API::Internal do
       end
 
       context "git push" do
-        context "gitaly disabled" do
+        context "gitaly disabled", :disable_gitaly do
           it "has the correct payload" do
-            allow(Gitlab::GitalyClient).to receive(:feature_enabled?).with(:ssh_receive_pack).and_return(false)
             push(key, project)
 
             expect(response).to have_gitlab_http_status(200)
@@ -368,7 +365,6 @@ describe API::Internal do
 
         context "gitaly enabled" do
           it "has the correct payload" do
-            allow(Gitlab::GitalyClient).to receive(:feature_enabled?).with(:ssh_receive_pack).and_return(true)
             push(key, project)
 
             expect(response).to have_gitlab_http_status(200)

spec/services/merge_requests/build_service_spec.rb

@@ -29,13 +29,27 @@ describe MergeRequests::BuildService do
 
   before do
     project.team << [user, :guest]
+  end
 
+  def stub_compare
     allow(CompareService).to receive_message_chain(:new, :execute).and_return(compare)
     allow(project).to receive(:commit).and_return(commit_1)
     allow(project).to receive(:commit).and_return(commit_2)
   end
 
-  describe 'execute' do
+  describe '#execute' do
+    it 'calls the compare service with the correct arguments' do
+      expect(CompareService).to receive(:new)
+                                  .with(project, Gitlab::Git::BRANCH_REF_PREFIX + source_branch)
+                                  .and_call_original
+
+      expect_any_instance_of(CompareService).to receive(:execute)
+                                                  .with(project, Gitlab::Git::BRANCH_REF_PREFIX + target_branch)
+                                                  .and_call_original
+
+      merge_request
+    end
+
     context 'missing source branch' do
       let(:source_branch) { '' }
 
@@ -52,6 +66,10 @@ describe MergeRequests::BuildService do
       let(:target_branch) { nil }
       let(:commits) { Commit.decorate([commit_1], project) }
 
+      before do
+        stub_compare
+      end
+
       it 'creates compare object with target branch as default branch' do
         expect(merge_request.compare).to be_present
         expect(merge_request.target_branch).to eq(project.default_branch)
@@ -77,6 +95,10 @@ describe MergeRequests::BuildService do
     context 'no commits in the diff' do
       let(:commits) { [] }
 
+      before do
+        stub_compare
+      end
+
       it 'allows the merge request to be created' do
         expect(merge_request.can_be_created).to eq(true)
       end
@@ -89,6 +111,10 @@ describe MergeRequests::BuildService do
     context 'one commit in the diff' do
       let(:commits) { Commit.decorate([commit_1], project) }
 
+      before do
+        stub_compare
+      end
+
       it 'allows the merge request to be created' do
         expect(merge_request.can_be_created).to eq(true)
       end
@@ -149,6 +175,10 @@ describe MergeRequests::BuildService do
     context 'more than one commit in the diff' do
       let(:commits) { Commit.decorate([commit_1, commit_2], project) }
 
+      before do
+        stub_compare
+      end
+
       it 'allows the merge request to be created' do
         expect(merge_request.can_be_created).to eq(true)
       end