Merge remote-tracking branch 'upstream/master' into ce-to-ee-2018-05-22

# Conflicts:
#	spec/javascripts/vue_mr_widget/components/mr_widget_author_spec.js
#	spec/models/project_spec.rb
#	spec/requests/api/projects_spec.rb

[ci skip]

app/controllers/groups/settings/badges_controller.rb

 module Groups
   module Settings
     class BadgesController < Groups::ApplicationController
-      include GrapeRouteHelpers::NamedRouteMatcher
+      include API::Helpers::RelatedResourcesHelpers
 
       before_action :authorize_admin_group!
 
       def index
-        @badge_api_endpoint = api_v4_groups_badges_path(id: @group.id)
+        @badge_api_endpoint = expose_url(api_v4_groups_badges_path(id: @group.id))
       end
     end
   end

app/controllers/projects/settings/badges_controller.rb

 module Projects
   module Settings
     class BadgesController < Projects::ApplicationController
-      include GrapeRouteHelpers::NamedRouteMatcher
+      include API::Helpers::RelatedResourcesHelpers
 
       before_action :authorize_admin_project!
 
       def index
-        @badge_api_endpoint = api_v4_projects_badges_path(id: @project.id)
+        @badge_api_endpoint = expose_url(api_v4_projects_badges_path(id: @project.id))
       end
     end
   end

app/models/project.rb

@@ -911,6 +911,13 @@ class Project < ActiveRecord::Base
     Gitlab::Routing.url_helpers.project_url(self)
   end
 
+  def readme_url
+    readme = repository.readme
+    if readme
+      Gitlab::Routing.url_helpers.project_blob_url(self, File.join(default_branch, readme.path))
+    end
+  end
+
   def new_issuable_address(author, address_type)
     return unless Gitlab::IncomingEmail.supports_issue_creation? && author
 

app/models/user.rb

@@ -111,7 +111,7 @@ class User < ActiveRecord::Base
   has_many :created_projects,         foreign_key: :creator_id, class_name: 'Project'
   has_many :users_star_projects, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
   has_many :starred_projects, through: :users_star_projects, source: :project
-  has_many :project_authorizations
+  has_many :project_authorizations, dependent: :delete_all # rubocop:disable Cop/ActiveRecordDependent
   has_many :authorized_projects, through: :project_authorizations, source: :project
 
   has_many :user_interacted_projects

changelogs/unreleased/45827-expose_readme_url_in_project_api.yml

+---
+title: Expose readme url in Project API
+merge_request: 18960
+author: Imre Farkas
+type: changed

changelogs/unreleased/ab-43706-composite-primary-keys.yml

+---
+title: Add NOT NULL constraints to project_authorizations.
+merge_request: 18980
+author:
+type: other

changelogs/unreleased/fj-46411-fix-badge-api-endpoint-route-with-relative-url.yml

+---
+title: Fixed badge api endpoint route when relative url is set
+merge_request: 19004
+author:
+type: fixed

changelogs/unreleased/rename-merge-request-widget-author-component.yml

+---
+title: Rename merge request widget author component
+merge_request: 19079
+author: George Tsiolis
+type: changed

db/migrate/20180517082340_add_not_null_constraints_to_project_authorizations.rb

+class AddNotNullConstraintsToProjectAuthorizations < ActiveRecord::Migration
+  include Gitlab::Database::MigrationHelpers
+
+  # Set this constant to true if this migration requires downtime.
+  DOWNTIME = false
+
+  def up
+    if Gitlab::Database.postgresql?
+      # One-pass version for PostgreSQL
+      execute <<~SQL
+      ALTER TABLE project_authorizations
+        ALTER COLUMN user_id SET NOT NULL,
+        ALTER COLUMN project_id SET NOT NULL,
+        ALTER COLUMN access_level SET NOT NULL
+      SQL
+    else
+      change_column_null :project_authorizations, :user_id, false
+      change_column_null :project_authorizations, :project_id, false
+      change_column_null :project_authorizations, :access_level, false
+    end
+  end
+
+  def down
+    if Gitlab::Database.postgresql?
+      # One-pass version for PostgreSQL
+      execute <<~SQL
+      ALTER TABLE project_authorizations
+        ALTER COLUMN user_id DROP NOT NULL,
+        ALTER COLUMN project_id DROP NOT NULL,
+        ALTER COLUMN access_level DROP NOT NULL
+      SQL
+    else
+      change_column_null :project_authorizations, :user_id, true
+      change_column_null :project_authorizations, :project_id, true
+      change_column_null :project_authorizations, :access_level, true
+    end
+  end
+end

db/optional_migrations/composite_primary_keys.rb

+# This migration adds a primary key constraint to tables
+# that only have a composite unique key.
+#
+# This is not strictly relevant to Rails (v4 does not
+# support composite primary keys). However this becomes
+# useful for e.g. PostgreSQL's logical replication (pglogical)
+# which requires all tables to have a primary key constraint.
+#
+# In that sense, the migration is optional and not strictly needed.
+class CompositePrimaryKeysMigration < ActiveRecord::Migration
+  include Gitlab::Database::MigrationHelpers
+
+  DOWNTIME = false
+
+  Index = Struct.new(:table, :name, :columns)
+
+  TABLES = [
+    Index.new(:issue_assignees, 'index_issue_assignees_on_issue_id_and_user_id', %i(issue_id user_id)),
+    Index.new(:user_interacted_projects, 'index_user_interacted_projects_on_project_id_and_user_id', %i(project_id user_id)),
+    Index.new(:merge_request_diff_files, 'index_merge_request_diff_files_on_mr_diff_id_and_order', %i(merge_request_diff_id relative_order)),
+    Index.new(:merge_request_diff_commits, 'index_merge_request_diff_commits_on_mr_diff_id_and_order', %i(merge_request_diff_id relative_order)),
+    Index.new(:project_authorizations, 'index_project_authorizations_on_user_id_project_id_access_level', %i(user_id project_id access_level)),
+    Index.new(:push_event_payloads, 'index_push_event_payloads_on_event_id', %i(event_id)),
+    Index.new(:schema_migrations, 'unique_schema_migrations', %(version)),
+  ]
+
+  disable_ddl_transaction!
+
+  def up
+    return unless Gitlab::Database.postgresql?
+
+    disable_statement_timeout
+    TABLES.each do |index|
+      add_primary_key(index)
+    end
+  end
+
+  def down
+    return unless Gitlab::Database.postgresql?
+
+    disable_statement_timeout
+    TABLES.each do |index|
+      remove_primary_key(index)
+    end
+  end
+
+  private
+  def add_primary_key(index)
+    execute "ALTER TABLE #{index.table} ADD PRIMARY KEY USING INDEX #{index.name}"
+  end
+
+  def remove_primary_key(index)
+    temp_index_name = "#{index.name[0..58]}_old"
+    rename_index index.table, index.name, temp_index_name if index_exists_by_name?(index.table, index.name)
+
+    # re-create unique key index
+    add_concurrent_index index.table, index.columns, unique: true, name: index.name
+
+    # This also drops the `temp_index_name` as this is owned by the constraint
+    execute "ALTER TABLE #{index.table} DROP CONSTRAINT IF EXISTS #{temp_index_name}"
+  end
+end
+

db/schema.rb

@@ -11,7 +11,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20180512061621) do
+ActiveRecord::Schema.define(version: 20180517082340) do
 
   # These are extensions that must be enabled in order to support this database
   enable_extension "plpgsql"
@@ -1902,9 +1902,9 @@ ActiveRecord::Schema.define(version: 20180512061621) do
   add_index "plans", ["name"], name: "index_plans_on_name", using: :btree
 
   create_table "project_authorizations", id: false, force: :cascade do |t|
-    t.integer "user_id"
-    t.integer "project_id"
-    t.integer "access_level"
+    t.integer "user_id", null: false
+    t.integer "project_id", null: false
+    t.integer "access_level", null: false
   end
 
   add_index "project_authorizations", ["project_id"], name: "index_project_authorizations_on_project_id", using: :btree

doc/api/projects.md

@@ -81,6 +81,7 @@ GET /projects
     "ssh_url_to_repo": "git@example.com:diaspora/diaspora-client.git",
     "http_url_to_repo": "http://example.com/diaspora/diaspora-client.git",
     "web_url": "http://example.com/diaspora/diaspora-client",
+    "readme_url": "http://example.com/diaspora/diaspora-client/blob/master/README.md",
     "tag_list": [
       "example",
       "disapora client"
@@ -151,6 +152,7 @@ GET /projects
     "ssh_url_to_repo": "git@example.com:brightbox/puppet.git",
     "http_url_to_repo": "http://example.com/brightbox/puppet.git",
     "web_url": "http://example.com/brightbox/puppet",
+    "readme_url": "http://example.com/brightbox/puppet/blob/master/README.md",
     "tag_list": [
       "example",
       "puppet"
@@ -269,6 +271,7 @@ GET /users/:user_id/projects
     "ssh_url_to_repo": "git@example.com:diaspora/diaspora-client.git",
     "http_url_to_repo": "http://example.com/diaspora/diaspora-client.git",
     "web_url": "http://example.com/diaspora/diaspora-client",
+    "readme_url": "http://example.com/diaspora/diaspora-client/blob/master/README.md",
     "tag_list": [
       "example",
       "disapora client"
@@ -338,6 +341,7 @@ GET /users/:user_id/projects
     "ssh_url_to_repo": "git@example.com:brightbox/puppet.git",
     "http_url_to_repo": "http://example.com/brightbox/puppet.git",
     "web_url": "http://example.com/brightbox/puppet",
+    "readme_url": "http://example.com/brightbox/puppet/blob/master/README.md",
     "tag_list": [
       "example",
       "puppet"
@@ -437,6 +441,7 @@ GET /projects/:id
   "ssh_url_to_repo": "git@example.com:diaspora/diaspora-project-site.git",
   "http_url_to_repo": "http://example.com/diaspora/diaspora-project-site.git",
   "web_url": "http://example.com/diaspora/diaspora-project-site",
+  "readme_url": "http://example.com/diaspora/diaspora-project-site/blob/master/README.md",
   "tag_list": [
     "example",
     "disapora project"
@@ -737,6 +742,7 @@ Example responses:
     "ssh_url_to_repo": "git@example.com:diaspora/diaspora-project-site.git",
     "http_url_to_repo": "http://example.com/diaspora/diaspora-project-site.git",
     "web_url": "http://example.com/diaspora/diaspora-project-site",
+    "readme_url": "http://example.com/diaspora/diaspora-project-site/blob/master/README.md",
     "tag_list": [
       "example",
       "disapora project"
@@ -815,6 +821,7 @@ Example response:
   "ssh_url_to_repo": "git@example.com:diaspora/diaspora-project-site.git",
   "http_url_to_repo": "http://example.com/diaspora/diaspora-project-site.git",
   "web_url": "http://example.com/diaspora/diaspora-project-site",
+  "readme_url": "http://example.com/diaspora/diaspora-project-site/blob/master/README.md",
   "tag_list": [
     "example",
     "disapora project"
@@ -892,6 +899,7 @@ Example response:
   "ssh_url_to_repo": "git@example.com:diaspora/diaspora-project-site.git",
   "http_url_to_repo": "http://example.com/diaspora/diaspora-project-site.git",
   "web_url": "http://example.com/diaspora/diaspora-project-site",
+  "readme_url": "http://example.com/diaspora/diaspora-project-site/blob/master/README.md",
   "tag_list": [
     "example",
     "disapora project"
@@ -993,6 +1001,7 @@ Example response:
   "ssh_url_to_repo": "git@example.com:diaspora/diaspora-project-site.git",
   "http_url_to_repo": "http://example.com/diaspora/diaspora-project-site.git",
   "web_url": "http://example.com/diaspora/diaspora-project-site",
+  "readme_url": "http://example.com/diaspora/diaspora-project-site/blob/master/README.md",
   "tag_list": [
     "example",
     "disapora project"
@@ -1088,6 +1097,7 @@ Example response:
   "ssh_url_to_repo": "git@example.com:diaspora/diaspora-project-site.git",
   "http_url_to_repo": "http://example.com/diaspora/diaspora-project-site.git",
   "web_url": "http://example.com/diaspora/diaspora-project-site",
+  "readme_url": "http://example.com/diaspora/diaspora-project-site/blob/master/README.md",
   "tag_list": [
     "example",
     "disapora project"

doc/user/project/integrations/jira.md

@@ -113,7 +113,7 @@ in the table below.
 | ----- | ----------- |
 | `Web URL` | The base URL to the JIRA instance web interface which is being linked to this GitLab project. E.g., `https://jira.example.com`. |
 | `JIRA API URL` | The base URL to the JIRA instance API. Web URL value will be used if not set. E.g., `https://jira-api.example.com`. |
-| `Username` | The user name created in [configuring JIRA step](#configuring-jira). |
+| `Username` | The user name created in [configuring JIRA step](#configuring-jira). Using the email address will cause `401 unauthorized`. |
 | `Password` |The password of the user created in [configuring JIRA step](#configuring-jira). |
 | `Transition ID` | This is the ID of a transition that moves issues to the desired state.  **Closing JIRA issues via commits or Merge Requests won't work if you don't set the ID correctly.** |
 

lib/api/entities.rb

@@ -125,7 +125,7 @@ module API
         # (fixed in https://github.com/rails/rails/pull/25976).
         project.tags.map(&:name).sort
       end
-      expose :ssh_url_to_repo, :http_url_to_repo, :web_url
+      expose :ssh_url_to_repo, :http_url_to_repo, :web_url, :readme_url
       expose :avatar_url do |project, options|
         project.avatar_url(only_path: false)
       end

lib/api/helpers/pagination.rb

@@ -2,67 +2,240 @@ module API
   module Helpers
     module Pagination
       def paginate(relation)
-        relation = add_default_order(relation)
+        strategy = if params[:pagination] == 'keyset' && Feature.enabled?('api_keyset_pagination')
+                     KeysetPaginationStrategy
+                   else
+                     DefaultPaginationStrategy
+                   end
 
-        relation.page(params[:page]).per(params[:per_page]).tap do |data|
-          add_pagination_headers(data)
-        end
+        strategy.new(self).paginate(relation)
       end
 
-      private
+      class KeysetPaginationInfo
+        attr_reader :relation, :request_context
 
-      def add_pagination_headers(paginated_data)
-        header 'X-Per-Page',    paginated_data.limit_value.to_s
-        header 'X-Page',        paginated_data.current_page.to_s
-        header 'X-Next-Page',   paginated_data.next_page.to_s
-        header 'X-Prev-Page',   paginated_data.prev_page.to_s
-        header 'Link',          pagination_links(paginated_data)
+        def initialize(relation, request_context)
+          # This is because it's rather complex to support multiple values with possibly different sort directions
+          # (and we don't need this in the API)
+          if relation.order_values.size > 1
+            raise "Pagination only supports ordering by a single column." \
+              "The following columns were given: #{relation.order_values.map { |v| v.expr.name }}"
+          end
 
-        return if data_without_counts?(paginated_data)
+          @relation = relation
+          @request_context = request_context
+        end
 
-        header 'X-Total',       paginated_data.total_count.to_s
-        header 'X-Total-Pages', total_pages(paginated_data).to_s
-      end
+        def fields
+          keys.zip(values).reject { |_, v| v.nil? }.to_h
+        end
 
-      def pagination_links(paginated_data)
-        request_url = request.url.split('?').first
-        request_params = params.clone
-        request_params[:per_page] = paginated_data.limit_value
+        def column_for_order_by(relation)
+          relation.order_values.first&.expr&.name
+        end
 
-        links = []
+        # Sort direction (`:asc` or `:desc`)
+        def sort
+          @sort ||= if order_by_primary_key?
+                      # Default order is by id DESC
+                      :desc
+                    else
+                      # API defaults to DESC order if param `sort` not present
+                      request_context.params[:sort]&.to_sym || :desc
+                    end
+        end
 
-        request_params[:page] = paginated_data.prev_page
-        links << %(<#{request_url}?#{request_params.to_query}>; rel="prev") if request_params[:page]
+        # Do we only sort by primary key?
+        def order_by_primary_key?
+          keys.size == 1 && keys.first == primary_key
+        end
 
-        request_params[:page] = paginated_data.next_page
-        links << %(<#{request_url}?#{request_params.to_query}>; rel="next") if request_params[:page]
+        def primary_key
+          relation.model.primary_key.to_sym
+        end
 
-        request_params[:page] = 1
-        links << %(<#{request_url}?#{request_params.to_query}>; rel="first")
+        def sort_ascending?
+          sort == :asc
+        end
 
-        unless data_without_counts?(paginated_data)
-          request_params[:page] = total_pages(paginated_data)
-          links << %(<#{request_url}?#{request_params.to_query}>; rel="last")
+        # Build hash of request parameters for a given record (relevant to pagination)
+        def params_for(record)
+          return {} unless record
+
+          keys.each_with_object({}) do |key, h|
+            h["ks_prev_#{key}".to_sym] = record.attributes[key.to_s]
+          end
         end
 
-        links.join(', ')
-      end
+        private
+
+        # All values present in request parameters that correspond to #keys.
+        def values
+          @values ||= keys.map do |key|
+            request_context.params["ks_prev_#{key}".to_sym]
+          end
+        end
 
-      def total_pages(paginated_data)
-        # Ensure there is in total at least 1 page
-        [paginated_data.total_pages, 1].max
+        # All keys relevant to pagination.
+        # This always includes the primary key. Optionally, the `order_by` key is prepended.
+        def keys
+          @keys ||= [column_for_order_by(relation), primary_key].compact.uniq
+        end
       end
 
-      def add_default_order(relation)
-        if relation.is_a?(ActiveRecord::Relation) && relation.order_values.empty?
-          relation = relation.order(:id)
+      class KeysetPaginationStrategy
+        attr_reader :request_context
+        delegate :params, :header, :request, to: :request_context
+
+        def initialize(request_context)
+          @request_context = request_context
+        end
+
+        def paginate(relation)
+          pagination = KeysetPaginationInfo.new(relation, request_context)
+
+          paged_relation = relation.limit(per_page)
+
+          if conds = conditions(pagination)
+            paged_relation = paged_relation.where(*conds)
+          end
+
+          # In all cases: sort by primary key (possibly in addition to another sort column)
+          paged_relation = paged_relation.order(pagination.primary_key => pagination.sort)
+
+          add_default_pagination_headers
+
+          if last_record = paged_relation.last
+            next_page_params = pagination.params_for(last_record)
+            add_navigation_links(next_page_params)
+          end
+
+          paged_relation
+        end
+
+        private
+
+        def conditions(pagination)
+          fields = pagination.fields
+
+          return nil if fields.empty?
+
+          placeholder = fields.map { '?' }
+
+          comp = if pagination.sort_ascending?
+                   '>'
+                 else
+                   '<'
+                 end
+
+          [
+            # Row value comparison:
+            # (A, B) < (a, b) <=> (A < a) OR (A = a AND B < b)
+            #     <=> A <= a AND ((A < a) OR (A = a AND B < b))
+            "(#{fields.keys.join(',')}) #{comp} (#{placeholder.join(',')})",
+            *fields.values
+          ]
+        end
+
+        def per_page
+          params[:per_page]
+        end
+
+        def add_default_pagination_headers
+          header 'X-Per-Page',    per_page.to_s
+        end
+
+        def add_navigation_links(next_page_params)
+          header 'X-Next-Page', page_href(next_page_params)
+          header 'Link', link_for('next', next_page_params)
         end
 
-        relation
+        def page_href(next_page_params)
+          request_url = request.url.split('?').first
+          request_params = params.dup
+          request_params[:per_page] = per_page
+
+          request_params.merge!(next_page_params) if next_page_params
+
+          "#{request_url}?#{request_params.to_query}"
+        end
+
+        def link_for(rel, next_page_params)
+          %(<#{page_href(next_page_params)}>; rel="#{rel}")
+        end
       end
 
-      def data_without_counts?(paginated_data)
-        paginated_data.is_a?(Kaminari::PaginatableWithoutCount)
+      class DefaultPaginationStrategy
+        attr_reader :request_context
+        delegate :params, :header, :request, to: :request_context
+
+        def initialize(request_context)
+          @request_context = request_context
+        end
+
+        def paginate(relation)
+          relation = add_default_order(relation)
+
+          relation.page(params[:page]).per(params[:per_page]).tap do |data|
+            add_pagination_headers(data)
+          end
+        end
+
+        private
+
+        def add_default_order(relation)
+          if relation.is_a?(ActiveRecord::Relation) && relation.order_values.empty?
+            relation = relation.order(:id)
+          end
+
+          relation
+        end
+
+        def add_pagination_headers(paginated_data)
+          header 'X-Per-Page',    paginated_data.limit_value.to_s
+          header 'X-Page',        paginated_data.current_page.to_s
+          header 'X-Next-Page',   paginated_data.next_page.to_s
+          header 'X-Prev-Page',   paginated_data.prev_page.to_s
+          header 'Link',          pagination_links(paginated_data)
+
+          return if data_without_counts?(paginated_data)
+
+          header 'X-Total',       paginated_data.total_count.to_s
+          header 'X-Total-Pages', total_pages(paginated_data).to_s
+        end
+
+        def pagination_links(paginated_data)
+          request_url = request.url.split('?').first
+          request_params = params.clone
+          request_params[:per_page] = paginated_data.limit_value
+
+          links = []
+
+          request_params[:page] = paginated_data.prev_page
+          links << %(<#{request_url}?#{request_params.to_query}>; rel="prev") if request_params[:page]
+
+          request_params[:page] = paginated_data.next_page
+          links << %(<#{request_url}?#{request_params.to_query}>; rel="next") if request_params[:page]
+
+          request_params[:page] = 1
+          links << %(<#{request_url}?#{request_params.to_query}>; rel="first")
+
+          unless data_without_counts?(paginated_data)
+            request_params[:page] = total_pages(paginated_data)
+            links << %(<#{request_url}?#{request_params.to_query}>; rel="last")
+          end
+
+          links.join(', ')
+        end
+
+        def total_pages(paginated_data)
+          # Ensure there is in total at least 1 page
+          [paginated_data.total_pages, 1].max
+        end
+
+        def data_without_counts?(paginated_data)
+          paginated_data.is_a?(Kaminari::PaginatableWithoutCount)
+        end
       end
     end
   end

lib/gitlab/serializer/pagination.rb

@@ -17,8 +17,6 @@ module Gitlab
         end
       end
 
-      private
-
       # Methods needed by `API::Helpers::Pagination`
       #
 

lib/tasks/migrate/composite_primary_keys.rake

+namespace :gitlab do
+  namespace :db do
+    desc 'GitLab | Adds primary keys to tables that only have composite unique keys'
+    task composite_primary_keys_add: :environment do
+      require Rails.root.join('db/optional_migrations/composite_primary_keys')
+      CompositePrimaryKeysMigration.new.up
+    end
+
+    desc 'GitLab | Removes previously added composite primary keys'
+    task composite_primary_keys_drop: :environment do
+      require Rails.root.join('db/optional_migrations/composite_primary_keys')
+      CompositePrimaryKeysMigration.new.down
+    end
+  end
+end

spec/fixtures/api/schemas/public_api/v4/projects.json

@@ -20,6 +20,7 @@
       "ssh_url_to_repo": { "type": "string" },
       "http_url_to_repo": { "type": "string" },
       "web_url": { "type": "string" },
+      "readme_url": { "type": ["string", "null"] },
       "avatar_url": { "type": ["string", "null"] },
       "star_count": { "type": "integer" },
       "forks_count": { "type": "integer" },

spec/javascripts/vue_mr_widget/components/mr_widget_author_spec.js

@@ -2,7 +2,11 @@ import Vue from 'vue';
 import MrWidgetAuthor from '~/vue_merge_request_widget/components/mr_widget_author.vue';
 import mountComponent from 'spec/helpers/vue_mount_component_helper';
 
+<<<<<<< HEAD
 describe('MrRWidgetAuthor', () => {
+=======
+describe('MrWidgetAuthor', () => {
+>>>>>>> upstream/master
   let vm;
 
   beforeEach(() => {

spec/lib/api/helpers/pagination_spec.rb

@@ -7,7 +7,203 @@ describe API::Helpers::Pagination do
     Class.new.include(described_class).new
   end
 
-  describe '#paginate' do
+  describe '#paginate (keyset pagination)' do
+    let(:value) { spy('return value') }
+
+    before do
+      allow(value).to receive(:to_query).and_return(value)
+
+      allow(subject).to receive(:header).and_return(value)
+      allow(subject).to receive(:params).and_return(value)
+      allow(subject).to receive(:request).and_return(value)
+    end
+
+    context 'when resource can be paginated' do
+      let!(:projects) do
+        [
+          create(:project, name: 'One'),
+          create(:project, name: 'Two'),
+          create(:project, name: 'Three')
+        ].sort_by { |e| -e.id } # sort by id desc (this is the default sort order for the API)
+      end
+
+      describe 'first page' do
+        before do
+          allow(subject).to receive(:params)
+            .and_return({ pagination: 'keyset', per_page: 2 })
+        end
+
+        it 'returns appropriate amount of resources' do
+          expect(subject.paginate(resource).count).to eq 2
+        end
+
+        it 'returns the first two records (by id desc)' do
+          expect(subject.paginate(resource)).to eq(projects[0..1])
+        end
+
+        it 'adds appropriate headers' do
+          expect_header('X-Per-Page', '2')
+          expect_header('X-Next-Page', "#{value}?ks_prev_id=#{projects[1].id}&pagination=keyset&per_page=2")
+
+          expect_header('Link', anything) do |_key, val|
+            expect(val).to include('rel="next"')
+          end
+
+          subject.paginate(resource)
+        end
+      end
+
+      describe 'second page' do
+        before do
+          allow(subject).to receive(:params)
+            .and_return({ pagination: 'keyset', per_page: 2, ks_prev_id: projects[1].id })
+        end
+
+        it 'returns appropriate amount of resources' do
+          expect(subject.paginate(resource).count).to eq 1
+        end
+
+        it 'returns the third record' do
+          expect(subject.paginate(resource)).to eq(projects[2..2])
+        end
+
+        it 'adds appropriate headers' do
+          expect_header('X-Per-Page', '2')
+          expect_header('X-Next-Page', "#{value}?ks_prev_id=#{projects[2].id}&pagination=keyset&per_page=2")
+
+          expect_header('Link', anything) do |_key, val|
+            expect(val).to include('rel="next"')
+          end
+
+          subject.paginate(resource)
+        end
+      end
+
+      describe 'third page' do
+        before do
+          allow(subject).to receive(:params)
+            .and_return({ pagination: 'keyset', per_page: 2, ks_prev_id: projects[2].id })
+        end
+
+        it 'returns appropriate amount of resources' do
+          expect(subject.paginate(resource).count).to eq 0
+        end
+
+        it 'adds appropriate headers' do
+          expect_header('X-Per-Page', '2')
+          expect(subject).not_to receive(:header).with('Link')
+
+          subject.paginate(resource)
+        end
+      end
+
+      context 'if order' do
+        context 'is not present' do
+          before do
+            allow(subject).to receive(:params)
+              .and_return({ pagination: 'keyset', per_page: 2 })
+          end
+
+          it 'is not present it adds default order(:id) desc' do
+            resource.order_values = []
+
+            paginated_relation = subject.paginate(resource)
+
+            expect(resource.order_values).to be_empty
+            expect(paginated_relation.order_values).to be_present
+            expect(paginated_relation.order_values.size).to eq(1)
+            expect(paginated_relation.order_values.first).to be_descending
+            expect(paginated_relation.order_values.first.expr.name).to eq :id
+          end
+        end
+
+        context 'is present' do
+          let(:resource) { Project.all.order(name: :desc) }
+          let!(:projects) do
+            [
+              create(:project, name: 'One'),
+              create(:project, name: 'Two'),
+              create(:project, name: 'Three'),
+              create(:project, name: 'Three'), # Note the duplicate name
+              create(:project, name: 'Four'),
+              create(:project, name: 'Five'),
+              create(:project, name: 'Six')
+            ]
+
+            # if we sort this by name descending, id descending, this yields:
+            # {
+            #   2 => "Two",
+            #   4 => "Three",
+            #   3 => "Three",
+            #   7 => "Six",
+            #   1 => "One",
+            #   5 => "Four",
+            #   6 => "Five"
+            # }
+            #
+            # (key is the id)
+          end
+
+          it 'it also orders by primary key' do
+            allow(subject).to receive(:params)
+              .and_return({ pagination: 'keyset', per_page: 2 })
+            paginated_relation = subject.paginate(resource)
+
+            expect(paginated_relation.order_values).to be_present
+            expect(paginated_relation.order_values.size).to eq(2)
+            expect(paginated_relation.order_values.first).to be_descending
+            expect(paginated_relation.order_values.first.expr.name).to eq :name
+            expect(paginated_relation.order_values.second).to be_descending
+            expect(paginated_relation.order_values.second.expr.name).to eq :id
+          end
+
+          it 'it returns the right records (first page)' do
+            allow(subject).to receive(:params)
+              .and_return({ pagination: 'keyset', per_page: 2 })
+            result = subject.paginate(resource)
+
+            expect(result.first).to eq(projects[1])
+            expect(result.second).to eq(projects[3])
+          end
+
+          it 'it returns the right records (second page)' do
+            allow(subject).to receive(:params)
+              .and_return({ pagination: 'keyset', ks_prev_id: projects[3].id, ks_prev_name: projects[3].name, per_page: 2 })
+            result = subject.paginate(resource)
+
+            expect(result.first).to eq(projects[2])
+            expect(result.second).to eq(projects[6])
+          end
+
+          it 'it returns the right records (third page), note increased per_page' do
+            allow(subject).to receive(:params)
+              .and_return({ pagination: 'keyset', ks_prev_id: projects[6].id, ks_prev_name: projects[6].name, per_page: 5 })
+            result = subject.paginate(resource)
+
+            expect(result.size).to eq(3)
+            expect(result.first).to eq(projects[0])
+            expect(result.second).to eq(projects[4])
+            expect(result.last).to eq(projects[5])
+          end
+
+          it 'it returns the right link to the next page' do
+            allow(subject).to receive(:params)
+              .and_return({ pagination: 'keyset', ks_prev_id: projects[3].id, ks_prev_name: projects[3].name, per_page: 2 })
+            expect_header('X-Per-Page', '2')
+            expect_header('X-Next-Page', "#{value}?ks_prev_id=#{projects[6].id}&ks_prev_name=#{projects[6].name}&pagination=keyset&per_page=2")
+
+            expect_header('Link', anything) do |_key, val|
+              expect(val).to include('rel="next"')
+            end
+
+            subject.paginate(resource)
+          end
+        end
+      end
+    end
+  end
+
+  describe '#paginate (default offset-based pagination)' do
     let(:value) { spy('return value') }
 
     before do
@@ -146,14 +342,14 @@ describe API::Helpers::Pagination do
         end
       end
     end
+  end
 
-    def expect_header(*args, &block)
-      expect(subject).to receive(:header).with(*args, &block)
-    end
+  def expect_header(*args, &block)
+    expect(subject).to receive(:header).with(*args, &block)
+  end
 
-    def expect_message(method)
-      expect(subject).to receive(method)
-        .at_least(:once).and_return(value)
-    end
+  def expect_message(method)
+    expect(subject).to receive(method)
+      .at_least(:once).and_return(value)
   end
 end

spec/models/project_spec.rb

@@ -504,11 +504,39 @@ describe Project do
     end
   end
 
+<<<<<<< HEAD
   describe "#kerberos_url_to_repo" do
     let(:project) { create(:project, path: "somewhere") }
 
     it 'returns valid kerberos url for this repo' do
       expect(project.kerberos_url_to_repo).to eq("#{Gitlab.config.build_gitlab_kerberos_url}/#{project.namespace.path}/somewhere.git")
+=======
+  describe "#readme_url" do
+    let(:project) { create(:project, :repository, path: "somewhere") }
+
+    context 'with a non-existing repository' do
+      it 'returns nil' do
+        allow(project.repository).to receive(:tree).with(:head).and_return(nil)
+
+        expect(project.readme_url).to be_nil
+      end
+    end
+
+    context 'with an existing repository' do
+      context 'when no README exists' do
+        it 'returns nil' do
+          allow_any_instance_of(Tree).to receive(:readme).and_return(nil)
+
+          expect(project.readme_url).to be_nil
+        end
+      end
+
+      context 'when a README exists' do
+        it 'returns the README' do
+          expect(project.readme_url).to eql("#{Gitlab.config.gitlab.url}/#{project.namespace.full_path}/somewhere/blob/master/README.md")
+        end
+      end
+>>>>>>> upstream/master
     end
   end
 

spec/requests/api/environments_spec.rb

@@ -15,7 +15,7 @@ describe API::Environments do
       it 'returns project environments' do
         project_data_keys = %w(
           id description default_branch tag_list
-          ssh_url_to_repo http_url_to_repo web_url
+          ssh_url_to_repo http_url_to_repo web_url readme_url
           name name_with_namespace
           path path_with_namespace
           star_count forks_count

spec/requests/api/projects_spec.rb

@@ -18,7 +18,7 @@ describe API::Projects do
   let(:user2) { create(:user) }
   let(:user3) { create(:user) }
   let(:admin) { create(:admin) }
-  let(:project) { create(:project, namespace: user.namespace) }
+  let(:project) { create(:project, :repository, namespace: user.namespace) }
   let(:project2) { create(:project, namespace: user.namespace) }
   let(:snippet) { create(:project_snippet, :public, author: user, project: project, title: 'example') }
   let(:project_member) { create(:project_member, :developer, user: user3, project: project) }
@@ -220,7 +220,7 @@ describe API::Projects do
         it 'returns a simplified version of all the projects' do
           expected_keys = %w(
             id description default_branch tag_list
-            ssh_url_to_repo http_url_to_repo web_url
+            ssh_url_to_repo http_url_to_repo web_url readme_url
             name name_with_namespace
             path path_with_namespace
             star_count forks_count
@@ -903,7 +903,11 @@ describe API::Projects do
         expect(json_response['only_allow_merge_if_pipeline_succeeds']).to eq(project.only_allow_merge_if_pipeline_succeeds)
         expect(json_response['only_allow_merge_if_all_discussions_are_resolved']).to eq(project.only_allow_merge_if_all_discussions_are_resolved)
         expect(json_response['merge_method']).to eq(project.merge_method.to_s)
+<<<<<<< HEAD
         expect(json_response).not_to have_key('repository_storage')
+=======
+        expect(json_response['readme_url']).to eq(project.readme_url)
+>>>>>>> upstream/master
       end
 
       it 'returns a project by path name' do

spec/requests/api/v3/projects_spec.rb

@@ -82,7 +82,7 @@ describe API::V3::Projects do
         it 'returns a simplified version of all the projects' do
           expected_keys = %w(
             id description default_branch tag_list
-            ssh_url_to_repo http_url_to_repo web_url
+            ssh_url_to_repo http_url_to_repo web_url readme_url
             name name_with_namespace
             path path_with_namespace
             star_count forks_count