Merge branch '237932-search-ui-implement-issue-scope-results-filter-by-state' into 'master'

Search UI add issue scope results filtering by state

See merge request gitlab-org/gitlab!39881

app/assets/javascripts/pages/search/show/index.js

 import Search from './search';
+import initStateFilter from '~/search/state_filter';
 
-document.addEventListener('DOMContentLoaded', () => new Search());
+document.addEventListener('DOMContentLoaded', () => {
+  initStateFilter();
+  return new Search();
+});

app/assets/javascripts/search/state_filter/components/state_filter.vue

+<script>
+import { GlDropdown, GlDropdownItem, GlDropdownDivider } from '@gitlab/ui';
+import { FILTER_STATES, FILTER_HEADER, FILTER_TEXT } from '../constants';
+import { setUrlParams, visitUrl } from '~/lib/utils/url_utility';
+
+const FILTERS_ARRAY = Object.values(FILTER_STATES);
+
+export default {
+  name: 'StateFilter',
+  components: {
+    GlDropdown,
+    GlDropdownItem,
+    GlDropdownDivider,
+  },
+  props: {
+    scope: {
+      type: String,
+      required: true,
+    },
+    state: {
+      type: String,
+      required: false,
+      default: FILTER_STATES.ANY.value,
+      validator: v => FILTERS_ARRAY.some(({ value }) => value === v),
+    },
+  },
+  computed: {
+    selectedFilterText() {
+      let filterText = FILTER_TEXT;
+      if (this.selectedFilter === FILTER_STATES.CLOSED.value) {
+        filterText = FILTER_STATES.CLOSED.label;
+      } else if (this.selectedFilter === FILTER_STATES.OPEN.value) {
+        filterText = FILTER_STATES.OPEN.label;
+      }
+      return filterText;
+    },
+    selectedFilter: {
+      get() {
+        if (FILTERS_ARRAY.some(({ value }) => value === this.state)) {
+          return this.state;
+        }
+
+        return FILTER_STATES.ANY.value;
+      },
+      set(state) {
+        visitUrl(setUrlParams({ state }));
+      },
+    },
+  },
+  methods: {
+    dropDownItemClass(filter) {
+      return {
+        'gl-border-b-solid gl-border-b-gray-100 gl-border-b-1 gl-pb-2! gl-mb-2':
+          filter === FILTER_STATES.ANY,
+      };
+    },
+    isFilterSelected(filter) {
+      return filter === this.selectedFilter;
+    },
+    handleFilterChange(state) {
+      this.selectedFilter = state;
+    },
+  },
+  filterStates: FILTER_STATES,
+  filterHeader: FILTER_HEADER,
+  filtersArray: FILTERS_ARRAY,
+};
+</script>
+
+<template>
+  <gl-dropdown
+    v-if="scope === 'issues'"
+    :text="selectedFilterText"
+    class="col-sm-3 gl-pt-4 gl-pl-0"
+  >
+    <header class="gl-text-center gl-font-weight-bold gl-font-lg">
+      {{ $options.filterHeader }}
+    </header>
+    <gl-dropdown-divider />
+    <gl-dropdown-item
+      v-for="filter in $options.filtersArray"
+      :key="filter.value"
+      :is-check-item="true"
+      :is-checked="isFilterSelected(filter.value)"
+      :class="dropDownItemClass(filter)"
+      @click="handleFilterChange(filter.value)"
+    >
+      {{ filter.label }}
+    </gl-dropdown-item>
+  </gl-dropdown>
+</template>

app/assets/javascripts/search/state_filter/constants.js

+import { __ } from '~/locale';
+
+export const FILTER_HEADER = __('Status');
+
+export const FILTER_TEXT = __('Any Status');
+
+export const FILTER_STATES = {
+  ANY: {
+    label: __('Any'),
+    value: 'all',
+  },
+  OPEN: {
+    label: __('Open'),
+    value: 'opened',
+  },
+  CLOSED: {
+    label: __('Closed'),
+    value: 'closed',
+  },
+};

app/assets/javascripts/search/state_filter/index.js

+import Vue from 'vue';
+import Translate from '~/vue_shared/translate';
+import StateFilter from './components/state_filter.vue';
+
+Vue.use(Translate);
+
+export default () => {
+  const el = document.getElementById('js-search-filter-by-state');
+
+  if (!el) return false;
+
+  return new Vue({
+    el,
+    components: {
+      StateFilter,
+    },
+    data() {
+      const { dataset } = this.$options.el;
+      return {
+        scope: dataset.scope,
+        state: dataset.state,
+      };
+    },
+
+    render(createElement) {
+      return createElement('state-filter', {
+        props: {
+          scope: this.scope,
+          state: this.state,
+        },
+      });
+    },
+  });
+};

app/finders/issues_finder.rb

@@ -8,7 +8,7 @@
 #   current_user - which user use
 #   params:
 #     scope: 'created_by_me' or 'assigned_to_me' or 'all'
-#     state: 'open' or 'closed' or 'all'
+#     state: 'opened' or 'closed' or 'all'
 #     group_id: integer
 #     project_id: integer
 #     milestone_title: string

app/helpers/search_helper.rb

 # frozen_string_literal: true
 
 module SearchHelper
-  SEARCH_PERMITTED_PARAMS = [:search, :scope, :project_id, :group_id, :repository_ref, :snippets].freeze
+  SEARCH_PERMITTED_PARAMS = [:search, :scope, :project_id, :group_id, :repository_ref, :snippets, :state].freeze
 
   def search_autocomplete_opts(term)
     return unless current_user

app/services/search/global_service.rb

@@ -13,7 +13,8 @@ module Search
     def execute
       Gitlab::SearchResults.new(current_user,
                                 params[:search],
-                                projects)
+                                projects,
+                                filters: { state: params[:state] })
     end
 
     def projects

app/services/search/group_service.rb

@@ -15,7 +15,8 @@ module Search
         current_user,
         params[:search],
         projects,
-        group: group
+        group: group,
+        filters: { state: params[:state] }
       )
     end
 

app/services/search/project_service.rb

@@ -12,7 +12,8 @@ module Search
       Gitlab::ProjectSearchResults.new(current_user,
                                        params[:search],
                                        project: project,
-                                       repository_ref: params[:repository_ref])
+                                       repository_ref: params[:repository_ref],
+                                       filters: { state: params[:state] })
     end
 
     def scope

app/views/search/_results.html.haml

@@ -22,6 +22,8 @@
         = _("in group %{link_to_group}").html_safe % { link_to_group: link_to_group }
   = render_if_exists 'shared/promotions/promote_advanced_search'
 
+  #js-search-filter-by-state{ 'v-cloak': true, data: { scope: @scope, state: params[:state] } }
+
   .results.gl-mt-3
     - if @scope == 'commits'
       %ul.content-list.commit-list

changelogs/unreleased/237932-search-ui-implement-issue-scope-results-filter-by-state.yml

+---
+title: Search UI Allow issue scope results filtering by state
+merge_request: 39881
+author:
+type: changed

ee/app/services/ee/search/global_service.rb

@@ -15,7 +15,8 @@ module EE
           current_user,
           params[:search],
           projects,
-          public_and_internal_projects: elastic_global
+          public_and_internal_projects: elastic_global,
+          filters: { state: params[:state] }
         )
       end
 

ee/app/services/ee/search/group_service.rb

@@ -24,7 +24,8 @@ module EE
           params[:search],
           projects,
           group: group,
-          public_and_internal_projects: elastic_global
+          public_and_internal_projects: elastic_global,
+          filters: { state: params[:state] }
         )
       end
     end

ee/app/services/ee/search/project_service.rb

@@ -14,7 +14,8 @@ module EE
           current_user,
           params[:search],
           project: project,
-          repository_ref: repository_ref
+          repository_ref: repository_ref,
+          filters: { state: params[:state] }
         )
       end
 

ee/lib/elastic/latest/issue_class_proxy.rb

@@ -21,12 +21,25 @@ module Elastic
         options[:features] = 'issues'
         query_hash = project_ids_filter(query_hash, options)
         query_hash = confidentiality_filter(query_hash, options)
+        query_hash = state_filter(query_hash, options)
 
         search(query_hash, options)
       end
 
       private
 
+      def state_filter(query_hash, options)
+        state = options[:state]
+
+        return query_hash if state.blank? || state == 'all'
+        return query_hash unless %w(all opened closed).include?(state)
+
+        filter = { match: { state: state } }
+
+        query_hash[:query][:bool][:filter] << filter
+        query_hash
+      end
+
       def confidentiality_filter(query_hash, options)
         current_user = options[:current_user]
         project_ids = options[:project_ids]

ee/lib/elastic/latest/issue_instance_proxy.rb

@@ -6,7 +6,7 @@ module Elastic
       def as_indexed_json(options = {})
         data = {}
 
-        # We don't use as_json(only: ...) because it calls all virtual and serialized attributtes
+        # We don't use as_json(only: ...) because it calls all virtual and serialized attributes
         # https://gitlab.com/gitlab-org/gitlab/issues/349
         [:id, :iid, :title, :description, :created_at, :updated_at, :state, :project_id, :author_id, :confidential].each do |attr|
           data[attr.to_s] = safely_read_attribute_for_elasticsearch(attr)

ee/lib/gitlab/elastic/group_search_results.rb

@@ -9,13 +9,14 @@ module Gitlab
       delegate :users, to: :generic_search_results
       delegate :limited_users_count, to: :generic_search_results
 
-      attr_reader :group, :default_project_filter
+      attr_reader :group, :default_project_filter, :filters
 
-      def initialize(current_user, query, limit_projects = nil, group:, public_and_internal_projects: false, default_project_filter: false)
+      def initialize(current_user, query, limit_projects = nil, group:, public_and_internal_projects: false, default_project_filter: false, filters: {})
         @group = group
         @default_project_filter = default_project_filter
+        @filters = filters
 
-        super(current_user, query, limit_projects, public_and_internal_projects: public_and_internal_projects)
+        super(current_user, query, limit_projects, public_and_internal_projects: public_and_internal_projects, filters: filters)
       end
 
       def generic_search_results
@@ -23,7 +24,8 @@ module Gitlab
           current_user,
           query,
           limit_projects,
-          group: group
+          group: group,
+          filters: filters
         )
       end
     end

ee/lib/gitlab/elastic/project_search_results.rb

@@ -6,16 +6,16 @@ module Gitlab
     # superclass inside a module, because autoloading can occur in a
     # different order between execution environments.
     class ProjectSearchResults < Gitlab::Elastic::SearchResults
-      attr_reader :project, :repository_ref
+      attr_reader :project, :repository_ref, :filters
 
       delegate :users, to: :generic_search_results
       delegate :limited_users_count, to: :generic_search_results
 
-      def initialize(current_user, query, project:, repository_ref: nil)
+      def initialize(current_user, query, project:, repository_ref: nil, filters: {})
         @project = project
         @repository_ref = repository_ref.presence || project.default_branch
 
-        super(current_user, query, [project], public_and_internal_projects: false)
+        super(current_user, query, [project], public_and_internal_projects: false, filters: filters)
       end
 
       def generic_search_results
@@ -23,7 +23,8 @@ module Gitlab
           current_user,
           query,
           project: project,
-          repository_ref: repository_ref
+          repository_ref: repository_ref,
+          filters: filters
         )
       end
 

ee/lib/gitlab/elastic/search_results.rb

@@ -7,7 +7,7 @@ module Gitlab
 
       DEFAULT_PER_PAGE = Gitlab::SearchResults::DEFAULT_PER_PAGE
 
-      attr_reader :current_user, :query, :public_and_internal_projects
+      attr_reader :current_user, :query, :public_and_internal_projects, :filters
 
       # Limit search results by passed projects
       # It allows us to search only for projects user has access to
@@ -16,11 +16,12 @@ module Gitlab
       delegate :users, to: :generic_search_results
       delegate :limited_users_count, to: :generic_search_results
 
-      def initialize(current_user, query, limit_projects = nil, public_and_internal_projects: true)
+      def initialize(current_user, query, limit_projects = nil, public_and_internal_projects: true, filters: {})
         @current_user = current_user
         @query = query
         @limit_projects = limit_projects
         @public_and_internal_projects = public_and_internal_projects
+        @filters = filters
       end
 
       def objects(scope, page: 1, per_page: DEFAULT_PER_PAGE, preload_method: nil)
@@ -221,7 +222,10 @@ module Gitlab
 
       def issues
         strong_memoize(:issues) do
-          Issue.elastic_search(query, options: base_options)
+          options = base_options
+          options[:state] = filters[:state] if filters.key?(:state)
+
+          Issue.elastic_search(query, options: options)
         end
       end
 

ee/spec/lib/gitlab/elastic/group_search_results_spec.rb

@@ -2,17 +2,32 @@
 
 require 'spec_helper'
 
-RSpec.describe Gitlab::Elastic::GroupSearchResults do
+RSpec.describe Gitlab::Elastic::GroupSearchResults, :elastic do
   let_it_be(:user) { create(:user) }
   let_it_be(:group) { create(:group) }
   let_it_be(:guest) { create(:user).tap { |u| group.add_user(u, Gitlab::Access::GUEST) } }
+  let(:filters) { {} }
+  let(:query) { '*' }
 
-  subject(:results) { described_class.new(user, query, group: group) }
+  subject(:results) { described_class.new(user, query, Project.all, group: group, filters: filters) }
 
   before do
     stub_ee_application_setting(elasticsearch_search: true, elasticsearch_indexing: true)
   end
 
+  context 'issues search', :sidekiq_inline do
+    let!(:project) { create(:project, :public, group: group) }
+    let!(:closed_issue) { create(:issue, :closed, project: project, title: 'foo closed') }
+    let!(:opened_issue) { create(:issue, :opened, project: project, title: 'foo opened') }
+    let(:query) { 'foo' }
+
+    include_examples 'search issues scope filters by state' do
+      before do
+        ensure_elasticsearch_index!
+      end
+    end
+  end
+
   context 'user search' do
     let(:query) { guest.username }
 
@@ -40,8 +55,6 @@ RSpec.describe Gitlab::Elastic::GroupSearchResults do
   end
 
   context 'query performance' do
-    let(:query) { '*' }
-
     include_examples 'does not hit Elasticsearch twice for objects and counts', %w|projects notes blobs wiki_blobs commits issues merge_requests milestones|
   end
 end

ee/spec/lib/gitlab/elastic/project_search_results_spec.rb

@@ -3,12 +3,13 @@
 require 'spec_helper'
 
 RSpec.describe Gitlab::Elastic::ProjectSearchResults, :elastic do
-  let(:user) { create(:user) }
-  let(:project) { create(:project, :public, :repository) }
+  let_it_be(:user) { create(:user) }
+  let_it_be(:project) { create(:project, :public, :repository) }
   let(:query) { 'hello world' }
   let(:repository_ref) { nil }
+  let(:filters) { {} }
 
-  subject(:results) { described_class.new(user, query, project: project, repository_ref: repository_ref) }
+  subject(:results) { described_class.new(user, query, project: project, repository_ref: repository_ref, filters: filters) }
 
   before do
     stub_ee_application_setting(elasticsearch_search: true, elasticsearch_indexing: true)
@@ -30,9 +31,9 @@ RSpec.describe Gitlab::Elastic::ProjectSearchResults, :elastic do
     it { expect(results.query).to eq('hello world') }
   end
 
-  describe "search", :sidekiq_might_not_need_inline do
-    let(:project) { create(:project, :public, :repository, :wiki_repo) }
-    let(:private_project) { create(:project, :repository, :wiki_repo) }
+  describe "search", :sidekiq_inline do
+    let_it_be(:project) { create(:project, :public, :repository, :wiki_repo) }
+    let_it_be(:private_project) { create(:project, :repository, :wiki_repo) }
 
     before do
       [project, private_project].each do |project|
@@ -56,7 +57,7 @@ RSpec.describe Gitlab::Elastic::ProjectSearchResults, :elastic do
     end
 
     context 'visibility checks' do
-      let(:project) { create(:project, :public, :wiki_repo) }
+      let_it_be(:project) { create(:project, :public, :wiki_repo) }
       let(:query) { 'term' }
 
       before do
@@ -67,6 +68,19 @@ RSpec.describe Gitlab::Elastic::ProjectSearchResults, :elastic do
         expect(results.wiki_blobs_count).to eq(1)
       end
     end
+
+    context 'filtering' do
+      include_examples 'search issues scope filters by state' do
+        let!(:project) { create(:project, :public) }
+        let!(:closed_issue) { create(:issue, :closed, project: project, title: 'foo closed') }
+        let!(:opened_issue) { create(:issue, :opened, project: project, title: 'foo opened') }
+        let(:query) { 'foo' }
+
+        before do
+          ensure_elasticsearch_index!
+        end
+      end
+    end
   end
 
   describe "search for commits in non-default branch" do
@@ -147,13 +161,14 @@ RSpec.describe Gitlab::Elastic::ProjectSearchResults, :elastic do
     it { expect(results.limited_users_count).to eq(1) }
 
     describe 'pagination' do
-      let(:query) {}
+      let(:query) { }
 
-      let!(:user2) { create(:user).tap { |u| project.add_user(u, Gitlab::Access::REPORTER) } }
+      let_it_be(:user2) { create(:user).tap { |u| project.add_user(u, Gitlab::Access::REPORTER) } }
 
       it 'returns the correct page of results' do
-        expect(results.objects('users', page: 1, per_page: 1)).to eq([project.owner])
-        expect(results.objects('users', page: 2, per_page: 1)).to eq([user2])
+        # UsersFinder defaults to order_id_desc, the newer result will be first
+        expect(results.objects('users', page: 1, per_page: 1)).to eq([user2])
+        expect(results.objects('users', page: 2, per_page: 1)).to eq([project.owner])
       end
 
       it 'returns the correct number of results for one page' do

ee/spec/lib/gitlab/elastic/search_results_spec.rb

@@ -171,6 +171,20 @@ RSpec.describe Gitlab::Elastic::SearchResults, :elastic, :sidekiq_might_not_need
       expect(results.objects('issues')).to be_empty
       expect(results.issues_count).to eq 0
     end
+
+    context 'filtering' do
+      let!(:project) { create(:project, :public) }
+      let!(:closed_issue) { create(:issue, :closed, project: project, title: 'foo closed') }
+      let!(:opened_issue) { create(:issue, :opened, project: project, title: 'foo opened') }
+
+      let(:results) { described_class.new(user, 'foo', [project], filters: filters) }
+
+      include_examples 'search issues scope filters by state' do
+        before do
+          ensure_elasticsearch_index!
+        end
+      end
+    end
   end
 
   describe 'notes' do

lib/gitlab/group_search_results.rb

@@ -4,10 +4,10 @@ module Gitlab
   class GroupSearchResults < SearchResults
     attr_reader :group
 
-    def initialize(current_user, query, limit_projects = nil, group:, default_project_filter: false)
+    def initialize(current_user, query, limit_projects = nil, group:, default_project_filter: false, filters: {})
       @group = group
 
-      super(current_user, query, limit_projects, default_project_filter: default_project_filter)
+      super(current_user, query, limit_projects, default_project_filter: default_project_filter, filters: filters)
     end
 
     # rubocop:disable CodeReuse/ActiveRecord

lib/gitlab/project_search_results.rb

@@ -4,11 +4,11 @@ module Gitlab
   class ProjectSearchResults < SearchResults
     attr_reader :project, :repository_ref
 
-    def initialize(current_user, query, project:, repository_ref: nil)
+    def initialize(current_user, query, project:, repository_ref: nil, filters: {})
       @project = project
       @repository_ref = repository_ref.presence
 
-      super(current_user, query, [project])
+      super(current_user, query, [project], filters: filters)
     end
 
     def objects(scope, page: nil, per_page: DEFAULT_PER_PAGE, preload_method: nil)

lib/gitlab/search_results.rb

@@ -7,7 +7,7 @@ module Gitlab
     DEFAULT_PAGE = 1
     DEFAULT_PER_PAGE = 20
 
-    attr_reader :current_user, :query
+    attr_reader :current_user, :query, :filters
 
     # Limit search results by passed projects
     # It allows us to search only for projects user has access to
@@ -19,11 +19,12 @@ module Gitlab
     # query
     attr_reader :default_project_filter
 
-    def initialize(current_user, query, limit_projects = nil, default_project_filter: false)
+    def initialize(current_user, query, limit_projects = nil, default_project_filter: false, filters: {})
       @current_user = current_user
       @query = query
       @limit_projects = limit_projects || Project.all
       @default_project_filter = default_project_filter
+      @filters = filters
     end
 
     def objects(scope, page: nil, per_page: DEFAULT_PER_PAGE, without_count: true, preload_method: nil)
@@ -190,6 +191,8 @@ module Gitlab
         else
           params[:search] = query
         end
+
+        params[:state] = filters[:state] if filters.key?(:state)
       end
     end
 

locale/gitlab.pot

@@ -2957,6 +2957,9 @@ msgstr ""
 msgid "Any Author"
 msgstr ""
 
+msgid "Any Status"
+msgstr ""
+
 msgid "Any branch"
 msgstr ""
 

spec/frontend/search/components/state_filter_spec.js

+import { shallowMount } from '@vue/test-utils';
+import { GlDropdown, GlDropdownItem } from '@gitlab/ui';
+import StateFilter from '~/search/state_filter/components/state_filter.vue';
+import { FILTER_STATES } from '~/search/state_filter/constants';
+import * as urlUtils from '~/lib/utils/url_utility';
+
+jest.mock('~/lib/utils/url_utility', () => ({
+  visitUrl: jest.fn(),
+  setUrlParams: jest.fn(),
+}));
+
+function createComponent(props = { scope: 'issues' }) {
+  return shallowMount(StateFilter, {
+    propsData: {
+      ...props,
+    },
+  });
+}
+
+describe('StateFilter', () => {
+  let wrapper;
+
+  beforeEach(() => {
+    wrapper = createComponent();
+  });
+
+  afterEach(() => {
+    wrapper.destroy();
+    wrapper = null;
+  });
+
+  const findGlDropdown = () => wrapper.find(GlDropdown);
+  const findGlDropdownItems = () => findGlDropdown().findAll(GlDropdownItem);
+  const findDropdownItemsText = () => findGlDropdownItems().wrappers.map(w => w.text());
+  const firstDropDownItem = () => findGlDropdownItems().at(0);
+
+  describe('template', () => {
+    describe.each`
+      scope               | showStateDropdown
+      ${'issues'}         | ${true}
+      ${'projects'}       | ${false}
+      ${'milestones'}     | ${false}
+      ${'users'}          | ${false}
+      ${'merge_requests'} | ${false}
+      ${'notes'}          | ${false}
+      ${'wiki_blobs'}     | ${false}
+      ${'blobs'}          | ${false}
+    `(`state dropdown`, ({ scope, showStateDropdown }) => {
+      beforeEach(() => {
+        wrapper = createComponent({ scope });
+      });
+
+      it(`does${showStateDropdown ? '' : ' not'} render when scope is ${scope}`, () => {
+        expect(findGlDropdown().exists()).toBe(showStateDropdown);
+      });
+    });
+
+    describe('Filter options', () => {
+      it('renders a dropdown item for each filterOption', () => {
+        expect(findDropdownItemsText()).toStrictEqual(
+          Object.keys(FILTER_STATES).map(key => {
+            return FILTER_STATES[key].label;
+          }),
+        );
+      });
+
+      it('clicking a dropdown item calls setUrlParams', () => {
+        const state = FILTER_STATES[Object.keys(FILTER_STATES)[0]].value;
+        firstDropDownItem().vm.$emit('click');
+
+        expect(urlUtils.setUrlParams).toHaveBeenCalledWith({ state });
+      });
+
+      it('clicking a dropdown item calls visitUrl', () => {
+        firstDropDownItem().vm.$emit('click');
+
+        expect(urlUtils.visitUrl).toHaveBeenCalled();
+      });
+    });
+  });
+});

spec/lib/gitlab/group_search_results_spec.rb

@@ -6,9 +6,22 @@ RSpec.describe Gitlab::GroupSearchResults do
   # group creation calls GroupFinder, so need to create the group
   # before so expect(GroupsFinder) check works
   let_it_be(:group) { create(:group) }
-  let(:user) { create(:user) }
+  let_it_be(:user) { create(:user) }
+  let(:filters) { {} }
+  let(:limit_projects) { Project.all }
+  let(:query) { 'gob' }
 
-  subject(:results) { described_class.new(user, 'gob', anything, group: group) }
+  subject(:results) { described_class.new(user, query, limit_projects, group: group, filters: filters) }
+
+  describe 'issues search' do
+    let_it_be(:project) { create(:project, :public, group: group) }
+    let_it_be(:opened_issue) { create(:issue, :opened, project: project, title: 'foo opened') }
+    let_it_be(:closed_issue) { create(:issue, :closed, project: project, title: 'foo closed') }
+    let(:query) { 'foo' }
+    let(:filters) { { state: 'opened' } }
+
+    include_examples 'search issues scope filters by state'
+  end
 
   describe 'user search' do
     subject(:objects) { results.objects('users') }

spec/lib/gitlab/project_search_results_spec.rb

@@ -5,12 +5,13 @@ require 'spec_helper'
 RSpec.describe Gitlab::ProjectSearchResults do
   include SearchHelpers
 
-  let(:user) { create(:user) }
-  let(:project) { create(:project) }
+  let_it_be(:user) { create(:user) }
+  let_it_be(:project) { create(:project) }
   let(:query) { 'hello world' }
   let(:repository_ref) { nil }
+  let(:filters) { {} }
 
-  subject(:results) { described_class.new(user, query, project: project, repository_ref: repository_ref) }
+  subject(:results) { described_class.new(user, query, project: project, repository_ref: repository_ref, filters: filters) }
 
   context 'with a repository_ref' do
     context 'when empty' do
@@ -258,6 +259,24 @@ RSpec.describe Gitlab::ProjectSearchResults do
     describe "confidential issues" do
       include_examples "access restricted confidential issues"
     end
+
+    context 'filtering' do
+      let_it_be(:project) { create(:project, :public) }
+      let_it_be(:closed_issue) { create(:issue, :closed, project: project, title: 'foo closed') }
+      let_it_be(:opened_issue) { create(:issue, :opened, project: project, title: 'foo opened') }
+      let(:query) { 'foo' }
+
+      include_examples 'search issues scope filters by state'
+    end
+
+    it 'filters issues when state is provided', :aggregate_failures do
+      closed_issue = create(:issue, :closed, project: project, title: "Revert: #{issue.title}")
+
+      results = described_class.new(project.creator, query, project: project, filters: { state: 'opened' })
+
+      expect(results.objects('issues')).not_to include closed_issue
+      expect(results.objects('issues')).to include issue
+    end
   end
 
   describe 'notes search' do

spec/lib/gitlab/search_results_spec.rb

@@ -6,13 +6,14 @@ RSpec.describe Gitlab::SearchResults do
   include ProjectForksHelper
   include SearchHelpers
 
-  let(:user) { create(:user) }
-  let!(:project) { create(:project, name: 'foo') }
-  let!(:issue) { create(:issue, project: project, title: 'foo') }
-  let!(:merge_request) { create(:merge_request, source_project: project, title: 'foo') }
-  let!(:milestone) { create(:milestone, project: project, title: 'foo') }
+  let_it_be(:user) { create(:user) }
+  let_it_be(:project) { create(:project, name: 'foo') }
+  let_it_be(:issue) { create(:issue, project: project, title: 'foo') }
+  let_it_be(:milestone) { create(:milestone, project: project, title: 'foo') }
+  let(:merge_request) { create(:merge_request, source_project: project, title: 'foo') }
+  let(:filters) { {} }
 
-  subject(:results) { described_class.new(user, 'foo', Project.all) }
+  subject(:results) { described_class.new(user, 'foo', Project.all, filters: filters) }
 
   context 'as a user with access' do
     before do
@@ -105,10 +106,10 @@ RSpec.describe Gitlab::SearchResults do
 
       describe '#limited_issues_count' do
         it 'runs single SQL query to get the limited amount of issues' do
-          create(:milestone, project: project, title: 'foo2')
+          create(:issue, project: project, title: 'foo2')
 
           expect(results).to receive(:issues).with(public_only: true).and_call_original
-          expect(results).not_to receive(:issues).with(no_args).and_call_original
+          expect(results).not_to receive(:issues).with(no_args)
 
           expect(results.limited_issues_count).to eq(1)
         end
@@ -165,6 +166,13 @@ RSpec.describe Gitlab::SearchResults do
 
         results.objects('issues')
       end
+
+      context 'filtering' do
+        let_it_be(:closed_issue) { create(:issue, :closed, project: project, title: 'foo closed') }
+        let_it_be(:opened_issue) { create(:issue, :opened, project: project, title: 'foo open') }
+
+        include_examples 'search issues scope filters by state'
+      end
     end
 
     describe '#users' do

spec/support/shared_examples/lib/gitlab/search_issue_state_filter_shared_examples.rb

+# frozen_string_literal: true
+
+RSpec.shared_examples 'search issues scope filters by state' do
+  context 'state not provided' do
+    let(:filters) { {} }
+
+    it 'returns opened and closed issues', :aggregate_failures do
+      expect(results.objects('issues')).to include opened_issue
+      expect(results.objects('issues')).to include closed_issue
+    end
+  end
+
+  context 'all state' do
+    let(:filters) { { state: 'all' } }
+
+    it 'returns opened and closed issues', :aggregate_failures do
+      expect(results.objects('issues')).to include opened_issue
+      expect(results.objects('issues')).to include closed_issue
+    end
+  end
+
+  context 'closed state' do
+    let(:filters) { { state: 'closed' } }
+
+    it 'returns only closed issues', :aggregate_failures do
+      expect(results.objects('issues')).not_to include opened_issue
+      expect(results.objects('issues')).to include closed_issue
+    end
+  end
+
+  context 'opened state' do
+    let(:filters) { { state: 'opened' } }
+
+    it 'returns only opened issues', :aggregate_failures do
+      expect(results.objects('issues')).to include opened_issue
+      expect(results.objects('issues')).not_to include closed_issue
+    end
+  end
+
+  context 'unsupported state' do
+    let(:filters) { { state: 'hello' } }
+
+    it 'returns only opened issues', :aggregate_failures do
+      expect(results.objects('issues')).to include opened_issue
+      expect(results.objects('issues')).to include closed_issue
+    end
+  end
+end

spec/views/search/_results.html.haml_spec.rb

@@ -54,6 +54,12 @@ RSpec.describe 'search/_results' do
           expect(rendered).to have_selector('[data-track-event=click_text]')
           expect(rendered).to have_selector('[data-track-property=search_result]')
         end
+
+        it 'renders the state filter drop down' do
+          render
+
+          expect(rendered).to have_selector('#js-search-filter-by-state')
+        end
       end
     end
   end