Bring one group board to CE

21 files changed, 833 insertions, 384 deletions

diff --git a/spec/controllers/groups/boards_controller_spec.rb b/spec/controllers/groups/boards_controller_spec.rb
new file mode 100644
index 00000000000..0f5bde62006
--- /dev/null
+++ b/spec/controllers/groups/boards_controller_spec.rb
@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe Groups::BoardsController do
+  let(:group) { create(:group) }
+  let(:user)    { create(:user) }
+
+  before do
+    group.add_master(user)
+    sign_in(user)
+  end
+
+  describe 'GET index' do
+    it 'creates a new board when group does not have one' do
+      expect { list_boards }.to change(group.boards, :count).by(1)
+    end
+
+    context 'when format is HTML' do
+      it 'renders template' do
+        list_boards
+
+        expect(response).to render_template :index
+        expect(response.content_type).to eq 'text/html'
+      end
+
+      context 'with unauthorized user' do
+        before do
+          allow(Ability).to receive(:allowed?).with(user, :read_cross_project, :global).and_return(true)
+          allow(Ability).to receive(:allowed?).with(user, :read_group, group).and_return(false)
+        end
+
+        it 'returns a not found 404 response' do
+          list_boards
+
+          expect(response).to have_gitlab_http_status(404)
+          expect(response.content_type).to eq 'text/html'
+        end
+      end
+    end
+
+    context 'when format is JSON' do
+      it 'return an array with one group board' do
+        create(:board, group: group)
+
+        list_boards format: :json
+
+        parsed_response = JSON.parse(response.body)
+
+        expect(response).to match_response_schema('boards')
+        expect(parsed_response.length).to eq 1
+      end
+
+      context 'with unauthorized user' do
+        before do
+          allow(Ability).to receive(:allowed?).with(user, :read_cross_project, :global).and_return(true)
+          allow(Ability).to receive(:allowed?).with(user, :read_group, group).and_return(false)
+        end
+
+        it 'returns a not found 404 response' do
+          list_boards format: :json
+
+          expect(response).to have_gitlab_http_status(404)
+          expect(response.content_type).to eq 'application/json'
+        end
+      end
+    end
+
+    def list_boards(format: :html)
+      get :index, group_id: group, format: format
+    end
+  end
+
+  describe 'GET show' do
+    let!(:board) { create(:board, group: group) }
+
+    context 'when format is HTML' do
+      it 'renders template' do
+        read_board board: board
+
+        expect(response).to render_template :show
+        expect(response.content_type).to eq 'text/html'
+      end
+
+      context 'with unauthorized user' do
+        before do
+          allow(Ability).to receive(:allowed?).with(user, :read_cross_project, :global).and_return(true)
+          allow(Ability).to receive(:allowed?).with(user, :read_group, group).and_return(false)
+        end
+
+        it 'returns a not found 404 response' do
+          read_board board: board
+
+          expect(response).to have_gitlab_http_status(404)
+          expect(response.content_type).to eq 'text/html'
+        end
+      end
+    end
+
+    context 'when format is JSON' do
+      it 'returns project board' do
+        read_board board: board, format: :json
+
+        expect(response).to match_response_schema('board')
+      end
+
+      context 'with unauthorized user' do
+        before do
+          allow(Ability).to receive(:allowed?).with(user, :read_cross_project, :global).and_return(true)
+          allow(Ability).to receive(:allowed?).with(user, :read_group, group).and_return(false)
+        end
+
+        it 'returns a not found 404 response' do
+          read_board board: board, format: :json
+
+          expect(response).to have_gitlab_http_status(404)
+          expect(response.content_type).to eq 'application/json'
+        end
+      end
+    end
+
+    context 'when board does not belong to group' do
+      it 'returns a not found 404 response' do
+        another_board = create(:board)
+
+        read_board board: another_board
+
+        expect(response).to have_gitlab_http_status(404)
+      end
+    end
+
+    def read_board(board:, format: :html)
+      get :show, group_id: group,
+                 id: board.to_param,
+                 format: format
+    end
+  end
+end
diff --git a/spec/factories/boards.rb b/spec/factories/boards.rb
index 1e125237ae8..6524bb4830c 100644
--- a/spec/factories/boards.rb
+++ b/spec/factories/boards.rb
@@ -1,6 +1,29 @@
 FactoryBot.define do
   factory :board do
-    project
+    transient do
+      project nil
+      group nil
+      project_id nil
+      group_id nil
+      parent nil
+    end
+
+    after(:build, :stub) do |board, evaluator|
+      if evaluator.group
+        board.group = evaluator.group
+      elsif evaluator.group_id
+        board.group_id = evaluator.group_id
+      elsif evaluator.project
+        board.project = evaluator.project
+      elsif evaluator.project_id
+        board.project_id = evaluator.project_id
+      elsif evaluator.parent
+        id = evaluator.parent.id
+        evaluator.parent.is_a?(Group) ? board.group_id = id : evaluator.project_id = id
+      else
+        board.project = create(:project, :empty_repo)
+      end
+    end
 
     after(:create) do |board|
       board.lists.create(list_type: :closed)
diff --git a/spec/helpers/boards_helper_spec.rb b/spec/helpers/boards_helper_spec.rb
index a3c5ab99c87..b22947911b9 100644
--- a/spec/helpers/boards_helper_spec.rb
+++ b/spec/helpers/boards_helper_spec.rb
@@ -1,6 +1,34 @@
 require 'spec_helper'
 
 describe BoardsHelper do
+  describe '#build_issue_link_base' do
+    context 'project board' do
+      it 'returns correct path for project board' do
+        @project = create(:project)
+        @board = create(:board, project: @project)
+
+        expect(build_issue_link_base).to eq("/#{@project.namespace.path}/#{@project.path}/issues")
+      end
+    end
+
+    context 'group board' do
+      let(:base_group) { create(:group, path: 'base') }
+
+      it 'returns correct path for base group' do
+        @board = create(:board, group: base_group)
+
+        expect(build_issue_link_base).to eq('/base/:project_path/issues')
+      end
+
+      it 'returns correct path for subgroup' do
+        subgroup = create(:group, parent: base_group, path: 'sub')
+        @board = create(:board, group: subgroup)
+
+        expect(build_issue_link_base).to eq('/base/sub/:project_path/issues')
+      end
+    end
+  end
+
   describe '#board_data' do
     let(:user) { create(:user) }
     let(:project) { create(:project) }
diff --git a/spec/javascripts/api_spec.js b/spec/javascripts/api_spec.js
index cf3a76d0d2e..5477581c1b9 100644
--- a/spec/javascripts/api_spec.js
+++ b/spec/javascripts/api_spec.js
@@ -137,6 +137,27 @@ describe('Api', () => {
         done();
       });
     });
+
+    it('creates a group label', (done) => {
+      const namespace = 'group/subgroup';
+      const labelData = { some: 'data' };
+      const expectedUrl = `${dummyUrlRoot}/groups/${namespace}/-/labels`;
+      const expectedData = {
+        label: labelData,
+      };
+      mock.onPost(expectedUrl).reply((config) => {
+        expect(config.data).toBe(JSON.stringify(expectedData));
+
+        return [200, {
+          name: 'test',
+        }];
+      });
+
+      Api.newLabel(namespace, undefined, labelData, (response) => {
+        expect(response.name).toBe('test');
+        done();
+      });
+    });
   });
 
   describe('groupProjects', () => {
diff --git a/spec/requests/api/group_boards_spec.rb b/spec/requests/api/group_boards_spec.rb
new file mode 100644
index 00000000000..894c94688ba
--- /dev/null
+++ b/spec/requests/api/group_boards_spec.rb
@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe API::GroupBoards do
+  set(:user) { create(:user) }
+  set(:non_member) { create(:user) }
+  set(:guest) { create(:user) }
+  set(:admin) { create(:user, :admin) }
+  set(:board_parent) { create(:group, :public) }
+
+  before do
+    board_parent.add_owner(user)
+  end
+
+  set(:project) { create(:project, :public, namespace: board_parent ) }
+
+  set(:dev_label) do
+    create(:group_label, title: 'Development', color: '#FFAABB', group: board_parent)
+  end
+
+  set(:test_label) do
+    create(:group_label, title: 'Testing', color: '#FFAACC', group: board_parent)
+  end
+
+  set(:ux_label) do
+    create(:group_label, title: 'UX', color: '#FF0000', group: board_parent)
+  end
+
+  set(:dev_list) do
+    create(:list, label: dev_label, position: 1)
+  end
+
+  set(:test_list) do
+    create(:list, label: test_label, position: 2)
+  end
+
+  set(:milestone) { create(:milestone, group: board_parent) }
+  set(:board_label) { create(:group_label, group: board_parent) }
+
+  set(:board) { create(:board, group: board_parent, lists: [dev_list, test_list]) }
+
+  it_behaves_like 'group and project boards', "/groups/:id/boards", false
+
+  describe 'POST /groups/:id/boards/lists' do
+    let(:url) { "/groups/#{board_parent.id}/boards/#{board.id}/lists" }
+
+    it 'does not create lists for child project labels' do
+      project_label = create(:label, project: project)
+
+      post api(url, user), label_id: project_label.id
+
+      expect(response).to have_gitlab_http_status(400)
+    end
+  end
+end
diff --git a/spec/services/boards/create_service_spec.rb b/spec/services/boards/create_service_spec.rb
index db51a524e79..a715261cd6c 100644
--- a/spec/services/boards/create_service_spec.rb
+++ b/spec/services/boards/create_service_spec.rb
@@ -2,34 +2,20 @@ require 'spec_helper'
 
 describe Boards::CreateService do
   describe '#execute' do
-    let(:project) { create(:project) }
+    context 'when board parent is a project' do
+      let(:parent) { create(:project) }
 
-    subject(:service) { described_class.new(project, double) }
+      subject(:service) { described_class.new(parent, double) }
 
-    context 'when project does not have a board' do
-      it 'creates a new board' do
-        expect { service.execute }.to change(Board, :count).by(1)
-      end
-
-      it 'creates the default lists' do
-        board = service.execute
-
-        expect(board.lists.size).to eq 2
-        expect(board.lists.first).to be_backlog
-        expect(board.lists.last).to be_closed
-      end
+      it_behaves_like 'boards create service'
     end
 
-    context 'when project has a board' do
-      before do
-        create(:board, project: project)
-      end
+    context 'when board parent is a group' do
+      let(:parent) { create(:group) }
 
-      it 'does not create a new board' do
-        expect(service).to receive(:can_create_board?) { false }
+      subject(:service) { described_class.new(parent, double) }
 
-        expect { service.execute }.not_to change(project.boards, :count)
-      end
+      it_behaves_like 'boards create service'
     end
   end
 end
diff --git a/spec/services/boards/issues/list_service_spec.rb b/spec/services/boards/issues/list_service_spec.rb
index ff5733b7064..b4efa3e44b6 100644
--- a/spec/services/boards/issues/list_service_spec.rb
+++ b/spec/services/boards/issues/list_service_spec.rb
@@ -2,98 +2,103 @@ require 'spec_helper'
 
 describe Boards::Issues::ListService do
   describe '#execute' do
-    let(:user)    { create(:user) }
-    let(:project) { create(:project) }
-    let(:board)   { create(:board, project: project) }
-
-    let(:bug) { create(:label, project: project, name: 'Bug') }
-    let(:development) { create(:label, project: project, name: 'Development') }
-    let(:testing)  { create(:label, project: project, name: 'Testing') }
-    let(:p1) { create(:label, title: 'P1', project: project, priority: 1) }
-    let(:p2) { create(:label, title: 'P2', project: project, priority: 2) }
-    let(:p3) { create(:label, title: 'P3', project: project, priority: 3) }
-
-    let!(:backlog) { create(:backlog_list, board: board) }
-    let!(:list1)   { create(:list, board: board, label: development, position: 0) }
-    let!(:list2)   { create(:list, board: board, label: testing, position: 1) }
-    let!(:closed)  { create(:closed_list, board: board) }
-
-    let!(:opened_issue1) { create(:labeled_issue, project: project, labels: [bug]) }
-    let!(:opened_issue2) { create(:labeled_issue, project: project, labels: [p2]) }
-    let!(:reopened_issue1) { create(:issue, :opened, project: project) }
-
-    let!(:list1_issue1) { create(:labeled_issue, project: project, labels: [p2, development]) }
-    let!(:list1_issue2) { create(:labeled_issue, project: project, labels: [development]) }
-    let!(:list1_issue3) { create(:labeled_issue, project: project, labels: [development, p1]) }
-    let!(:list2_issue1) { create(:labeled_issue, project: project, labels: [testing]) }
-
-    let!(:closed_issue1) { create(:labeled_issue, :closed, project: project, labels: [bug]) }
-    let!(:closed_issue2) { create(:labeled_issue, :closed, project: project, labels: [p3]) }
-    let!(:closed_issue3) { create(:issue, :closed, project: project) }
-    let!(:closed_issue4) { create(:labeled_issue, :closed, project: project, labels: [p1]) }
-    let!(:closed_issue5) { create(:labeled_issue, :closed, project: project, labels: [development]) }
-
-    before do
-      project.add_developer(user)
-    end
-
-    it 'delegates search to IssuesFinder' do
-      params = { board_id: board.id, id: list1.id }
-
-      expect_any_instance_of(IssuesFinder).to receive(:execute).once.and_call_original
+    context 'when parent is a project' do
+      let(:user)    { create(:user) }
+      let(:project) { create(:project) }
+      let(:board)   { create(:board, project: project) }
+
+      let(:m1) { create(:milestone, project: project) }
+      let(:m2) { create(:milestone, project: project) }
+
+      let(:bug) { create(:label, project: project, name: 'Bug') }
+      let(:development) { create(:label, project: project, name: 'Development') }
+      let(:testing)  { create(:label, project: project, name: 'Testing') }
+      let(:p1) { create(:label, title: 'P1', project: project, priority: 1) }
+      let(:p2) { create(:label, title: 'P2', project: project, priority: 2) }
+      let(:p3) { create(:label, title: 'P3', project: project, priority: 3) }
+
+      let!(:backlog) { create(:backlog_list, board: board) }
+      let!(:list1)   { create(:list, board: board, label: development, position: 0) }
+      let!(:list2)   { create(:list, board: board, label: testing, position: 1) }
+      let!(:closed)  { create(:closed_list, board: board) }
+
+      let!(:opened_issue1) { create(:labeled_issue, project: project, milestone: m1, title: 'Issue 1', labels: [bug]) }
+      let!(:opened_issue2) { create(:labeled_issue, project: project, milestone: m2, title: 'Issue 2', labels: [p2]) }
+      let!(:reopened_issue1) { create(:issue, :opened, project: project, title: 'Issue 3' ) }
+
+      let!(:list1_issue1) { create(:labeled_issue, project: project, milestone: m1, labels: [p2, development]) }
+      let!(:list1_issue2) { create(:labeled_issue, project: project, milestone: m2, labels: [development]) }
+      let!(:list1_issue3) { create(:labeled_issue, project: project, milestone: m1, labels: [development, p1]) }
+      let!(:list2_issue1) { create(:labeled_issue, project: project, milestone: m1, labels: [testing]) }
+
+      let!(:closed_issue1) { create(:labeled_issue, :closed, project: project, labels: [bug]) }
+      let!(:closed_issue2) { create(:labeled_issue, :closed, project: project, labels: [p3]) }
+      let!(:closed_issue3) { create(:issue, :closed, project: project) }
+      let!(:closed_issue4) { create(:labeled_issue, :closed, project: project, labels: [p1]) }
+      let!(:closed_issue5) { create(:labeled_issue, :closed, project: project, labels: [development]) }
+
+      let(:parent) { project }
+
+      before do
+        project.add_developer(user)
+      end
 
-      described_class.new(project, user, params).execute
+      it_behaves_like 'issues list service'
     end
 
-    context 'issues are ordered by priority' do
-      it 'returns opened issues when list_id is missing' do
-        params = { board_id: board.id }
-
-        issues = described_class.new(project, user, params).execute
-
-        expect(issues).to eq [opened_issue2, reopened_issue1, opened_issue1]
-      end
+    context 'when parent is a group' do
+      let(:user)    { create(:user) }
+      let(:group) { create(:group) }
+      let(:project) { create(:project, :empty_repo, namespace: group) }
+      let(:project1) { create(:project, :empty_repo, namespace: group) }
+      let(:board)   { create(:board, group: group) }
 
-      it 'returns opened issues when listing issues from Backlog' do
-        params = { board_id: board.id, id: backlog.id }
+      let(:m1) { create(:milestone, group: group) }
+      let(:m2) { create(:milestone, group: group) }
 
-        issues = described_class.new(project, user, params).execute
+      let(:bug) { create(:group_label, group: group, name: 'Bug') }
+      let(:development) { create(:group_label, group: group, name: 'Development') }
+      let(:testing)  { create(:group_label, group: group, name: 'Testing') }
 
-        expect(issues).to eq [opened_issue2, reopened_issue1, opened_issue1]
-      end
+      let(:p1) { create(:group_label, title: 'P1', group: group) }
+      let(:p2) { create(:group_label, title: 'P2', group: group) }
+      let(:p3) { create(:group_label, title: 'P3', group: group) }
 
-      it 'returns closed issues when listing issues from Closed' do
-        params = { board_id: board.id, id: closed.id }
+      let(:p1_project) { create(:label, title: 'P1_project', project: project, priority: 1) }
+      let(:p2_project) { create(:label, title: 'P2_project', project: project, priority: 2) }
+      let(:p3_project) { create(:label, title: 'P3_project', project: project, priority: 3) }
 
-        issues = described_class.new(project, user, params).execute
+      let(:p1_project1) { create(:label, title: 'P1_project1', project: project1, priority: 1) }
+      let(:p2_project1) { create(:label, title: 'P2_project1', project: project1, priority: 2) }
+      let(:p3_project1) { create(:label, title: 'P3_project1', project: project1, priority: 3) }
 
-        expect(issues).to eq [closed_issue4, closed_issue2, closed_issue5, closed_issue3, closed_issue1]
-      end
+      let!(:backlog) { create(:backlog_list, board: board) }
+      let!(:list1)   { create(:list, board: board, label: development, position: 0) }
+      let!(:list2)   { create(:list, board: board, label: testing, position: 1) }
+      let!(:closed)  { create(:closed_list, board: board) }
 
-      it 'returns opened issues that have label list applied when listing issues from a label list' do
-        params = { board_id: board.id, id: list1.id }
+      let!(:opened_issue1) { create(:labeled_issue, project: project, milestone: m1, title: 'Issue 1', labels: [bug]) }
+      let!(:opened_issue2) { create(:labeled_issue, project: project, milestone: m2, title: 'Issue 2', labels: [p2, p2_project]) }
+      let!(:reopened_issue1) { create(:issue, state: 'opened', project: project, title: 'Issue 3', closed_at: Time.now ) }
 
-        issues = described_class.new(project, user, params).execute
+      let!(:list1_issue1) { create(:labeled_issue, project: project, milestone: m1, labels: [p2, p2_project, development]) }
+      let!(:list1_issue2) { create(:labeled_issue, project: project, milestone: m2, labels: [development]) }
+      let!(:list1_issue3) { create(:labeled_issue, project: project1, milestone: m1, labels: [development, p1, p1_project1]) }
+      let!(:list2_issue1) { create(:labeled_issue, project: project1, milestone: m1, labels: [testing]) }
 
-        expect(issues).to eq [list1_issue3, list1_issue1, list1_issue2]
-      end
-    end
+      let!(:closed_issue1) { create(:labeled_issue, :closed, project: project, labels: [bug]) }
+      let!(:closed_issue2) { create(:labeled_issue, :closed, project: project, labels: [p3, p3_project]) }
+      let!(:closed_issue3) { create(:issue, :closed, project: project1) }
+      let!(:closed_issue4) { create(:labeled_issue, :closed, project: project1, labels: [p1, p1_project1]) }
+      let!(:closed_issue5) { create(:labeled_issue, :closed, project: project1, labels: [development]) }
 
-    context 'with list that does not belong to the board' do
-      it 'raises an error' do
-        list = create(:list)
-        service = described_class.new(project, user, board_id: board.id, id: list.id)
+      let(:parent) { group }
 
-        expect { service.execute }.to raise_error(ActiveRecord::RecordNotFound)
+      before do
+        group.add_developer(user)
       end
-    end
-
-    context 'with invalid list id' do
-      it 'raises an error' do
-        service = described_class.new(project, user, board_id: board.id, id: nil)
 
-        expect { service.execute }.to raise_error(ActiveRecord::RecordNotFound)
-      end
+      it_behaves_like 'issues list service'
     end
   end
 end
diff --git a/spec/services/boards/issues/move_service_spec.rb b/spec/services/boards/issues/move_service_spec.rb
index 280e411683e..0a6b6d880d3 100644
--- a/spec/services/boards/issues/move_service_spec.rb
+++ b/spec/services/boards/issues/move_service_spec.rb
@@ -2,108 +2,53 @@ require 'spec_helper'
 
 describe Boards::Issues::MoveService do
   describe '#execute' do
-    let(:user)    { create(:user) }
-    let(:project) { create(:project) }
-    let(:board1)  { create(:board, project: project) }
-
-    let(:bug) { create(:label, project: project, name: 'Bug') }
-    let(:development) { create(:label, project: project, name: 'Development') }
-    let(:testing)  { create(:label, project: project, name: 'Testing') }
-
-    let!(:list1)   { create(:list, board: board1, label: development, position: 0) }
-    let!(:list2)   { create(:list, board: board1, label: testing, position: 1) }
-    let!(:closed)  { create(:closed_list, board: board1) }
-
-    before do
-      project.add_developer(user)
-    end
-
-    context 'when moving an issue between lists' do
-      let(:issue)  { create(:labeled_issue, project: project, labels: [bug, development]) }
-      let(:params) { { board_id: board1.id, from_list_id: list1.id, to_list_id: list2.id } }
-
-      it 'delegates the label changes to Issues::UpdateService' do
-        expect_any_instance_of(Issues::UpdateService).to receive(:execute).with(issue).once
-
-        described_class.new(project, user, params).execute(issue)
-      end
-
-      it 'removes the label from the list it came from and adds the label of the list it goes to' do
-        described_class.new(project, user, params).execute(issue)
-
-        expect(issue.reload.labels).to contain_exactly(bug, testing)
-      end
-    end
-
-    context 'when moving to closed' do
+    context 'when parent is a project' do
+      let(:user) { create(:user) }
+      let(:project) { create(:project) }
+      let(:board1) { create(:board, project: project) }
       let(:board2) { create(:board, project: project) }
+
+      let(:bug) { create(:label, project: project, name: 'Bug') }
+      let(:development) { create(:label, project: project, name: 'Development') }
+      let(:testing)  { create(:label, project: project, name: 'Testing') }
       let(:regression) { create(:label, project: project, name: 'Regression') }
-      let!(:list3) { create(:list, board: board2, label: regression, position: 1) }
 
-      let(:issue)  { create(:labeled_issue, project: project, labels: [bug, development, testing, regression]) }
-      let(:params) { { board_id: board1.id, from_list_id: list2.id, to_list_id: closed.id } }
+      let!(:list1)   { create(:list, board: board1, label: development, position: 0) }
+      let!(:list2)   { create(:list, board: board1, label: testing, position: 1) }
+      let!(:closed)  { create(:closed_list, board: board1) }
 
-      it 'delegates the close proceedings to Issues::CloseService' do
-        expect_any_instance_of(Issues::CloseService).to receive(:execute).with(issue).once
+      let(:parent) { project }
 
-        described_class.new(project, user, params).execute(issue)
+      before do
+        parent.add_developer(user)
       end
 
-      it 'removes all list-labels from project boards and close the issue' do
-        described_class.new(project, user, params).execute(issue)
-        issue.reload
-
-        expect(issue.labels).to contain_exactly(bug)
-        expect(issue).to be_closed
-      end
+      it_behaves_like 'issues move service'
     end
 
-    context 'when moving from closed' do
-      let(:issue)  { create(:labeled_issue, :closed, project: project, labels: [bug]) }
-      let(:params) { { board_id: board1.id, from_list_id: closed.id, to_list_id: list2.id } }
-
-      it 'delegates the re-open proceedings to Issues::ReopenService' do
-        expect_any_instance_of(Issues::ReopenService).to receive(:execute).with(issue).once
-
-        described_class.new(project, user, params).execute(issue)
-      end
-
-      it 'adds the label of the list it goes to and reopen the issue' do
-        described_class.new(project, user, params).execute(issue)
-        issue.reload
-
-        expect(issue.labels).to contain_exactly(bug, testing)
-        expect(issue).to be_opened
-      end
-    end
+    context 'when parent is a group' do
+      let(:user) { create(:user) }
+      let(:group) { create(:group) }
+      let(:project) { create(:project, namespace: group) }
+      let(:board1) { create(:board, group: group) }
+      let(:board2) { create(:board, group: group) }
 
-    context 'when moving to same list' do
-      let(:issue)   { create(:labeled_issue, project: project, labels: [bug, development]) }
-      let(:issue1)  { create(:labeled_issue, project: project, labels: [bug, development]) }
-      let(:issue2)  { create(:labeled_issue, project: project, labels: [bug, development]) }
-      let(:params)  { { board_id: board1.id, from_list_id: list1.id, to_list_id: list1.id } }
+      let(:bug) { create(:group_label, group: group, name: 'Bug') }
+      let(:development) { create(:group_label, group: group, name: 'Development') }
+      let(:testing)  { create(:group_label, group: group, name: 'Testing') }
+      let(:regression) { create(:group_label, group: group, name: 'Regression') }
 
-      it 'returns false' do
-        expect(described_class.new(project, user, params).execute(issue)).to eq false
-      end
+      let!(:list1)   { create(:list, board: board1, label: development, position: 0) }
+      let!(:list2)   { create(:list, board: board1, label: testing, position: 1) }
+      let!(:closed)  { create(:closed_list, board: board1) }
 
-      it 'keeps issues labels' do
-        described_class.new(project, user, params).execute(issue)
+      let(:parent) { group }
 
-        expect(issue.reload.labels).to contain_exactly(bug, development)
+      before do
+        parent.add_developer(user)
       end
 
-      it 'sorts issues' do
-        [issue, issue1, issue2].each do |issue|
-          issue.move_to_end && issue.save!
-        end
-
-        params.merge!(move_after_id: issue1.id, move_before_id: issue2.id)
-
-        described_class.new(project, user, params).execute(issue)
-
-        expect(issue.relative_position).to be_between(issue1.relative_position, issue2.relative_position)
-      end
+      it_behaves_like 'issues move service'
     end
   end
 end
diff --git a/spec/services/boards/list_service_spec.rb b/spec/services/boards/list_service_spec.rb
index 1d0be99fb35..7518e9e9b75 100644
--- a/spec/services/boards/list_service_spec.rb
+++ b/spec/services/boards/list_service_spec.rb
@@ -2,36 +2,20 @@ require 'spec_helper'
 
 describe Boards::ListService do
   describe '#execute' do
-    let(:project) { create(:project) }
+    context 'when board parent is a project' do
+      let(:parent) { create(:project) }
 
-    subject(:service) { described_class.new(project, double) }
+      subject(:service) { described_class.new(parent, double) }
 
-    context 'when project does not have a board' do
-      it 'creates a new project board' do
-        expect { service.execute }.to change(project.boards, :count).by(1)
-      end
-
-      it 'delegates the project board creation to Boards::CreateService' do
-        expect_any_instance_of(Boards::CreateService).to receive(:execute).once
-
-        service.execute
-      end
+      it_behaves_like 'boards list service'
     end
 
-    context 'when project has a board' do
-      before do
-        create(:board, project: project)
-      end
-
-      it 'does not create a new board' do
-        expect { service.execute }.not_to change(project.boards, :count)
-      end
-    end
+    context 'when board parent is a group' do
+      let(:parent) { create(:group) }
 
-    it 'returns project boards' do
-      board = create(:board, project: project)
+      subject(:service) { described_class.new(parent, double) }
 
-      expect(service.execute).to match_array [board]
+      it_behaves_like 'boards list service'
     end
   end
 end
diff --git a/spec/services/boards/lists/create_service_spec.rb b/spec/services/boards/lists/create_service_spec.rb
index d5322e1bb21..7d3f5f86deb 100644
--- a/spec/services/boards/lists/create_service_spec.rb
+++ b/spec/services/boards/lists/create_service_spec.rb
@@ -2,62 +2,77 @@ require 'spec_helper'
 
 describe Boards::Lists::CreateService do
   describe '#execute' do
-    let(:project) { create(:project) }
-    let(:board)   { create(:board, project: project) }
-    let(:user)    { create(:user) }
-    let(:label)   { create(:label, project: project, name: 'in-progress') }
+    shared_examples 'creating board lists' do
+      let(:user)    { create(:user) }
 
-    subject(:service) { described_class.new(project, user, label_id: label.id) }
+      subject(:service) { described_class.new(parent, user, label_id: label.id) }
 
-    before do
-      project.add_developer(user)
-    end
+      before do
+        parent.add_developer(user)
+      end
 
-    context 'when board lists is empty' do
-      it 'creates a new list at beginning of the list' do
-        list = service.execute(board)
+      context 'when board lists is empty' do
+        it 'creates a new list at beginning of the list' do
+          list = service.execute(board)
 
-        expect(list.position).to eq 0
+          expect(list.position).to eq 0
+        end
       end
-    end
 
-    context 'when board lists has the done list' do
-      it 'creates a new list at beginning of the list' do
-        list = service.execute(board)
+      context 'when board lists has the done list' do
+        it 'creates a new list at beginning of the list' do
+          list = service.execute(board)
 
-        expect(list.position).to eq 0
+          expect(list.position).to eq 0
+        end
       end
-    end
 
-    context 'when board lists has labels lists' do
-      it 'creates a new list at end of the lists' do
-        create(:list, board: board, position: 0)
-        create(:list, board: board, position: 1)
+      context 'when board lists has labels lists' do
+        it 'creates a new list at end of the lists' do
+          create(:list, board: board, position: 0)
+          create(:list, board: board, position: 1)
 
-        list = service.execute(board)
+          list = service.execute(board)
 
-        expect(list.position).to eq 2
+          expect(list.position).to eq 2
+        end
       end
-    end
 
-    context 'when board lists has label and done lists' do
-      it 'creates a new list at end of the label lists' do
-        list1 = create(:list, board: board, position: 0)
+      context 'when board lists has label and done lists' do
+        it 'creates a new list at end of the label lists' do
+          list1 = create(:list, board: board, position: 0)
 
-        list2 = service.execute(board)
+          list2 = service.execute(board)
 
-        expect(list1.reload.position).to eq 0
-        expect(list2.reload.position).to eq 1
+          expect(list1.reload.position).to eq 0
+          expect(list2.reload.position).to eq 1
+        end
       end
-    end
 
-    context 'when provided label does not belongs to the project' do
-      it 'raises an error' do
-        label = create(:label, name: 'in-development')
-        service = described_class.new(project, user, label_id: label.id)
+      context 'when provided label does not belongs to the parent' do
+        it 'raises an error' do
+          label = create(:label, name: 'in-development')
+          service = described_class.new(parent, user, label_id: label.id)
 
-        expect { service.execute(board) }.to raise_error(ActiveRecord::RecordNotFound)
+          expect { service.execute(board) }.to raise_error(ActiveRecord::RecordNotFound)
+        end
       end
     end
+
+    context 'when board parent is a project' do
+      let(:parent) { create(:project) }
+      let(:board) { create(:board, project: parent) }
+      let(:label) { create(:label, project: parent, name: 'in-progress') }
+
+      it_behaves_like 'creating board lists'
+    end
+
+    context 'when board parent is a group' do
+      let(:parent) { create(:group) }
+      let(:board) { create(:board, group: parent) }
+      let(:label) { create(:group_label, group: parent, name: 'in-progress') }
+
+      it_behaves_like 'creating board lists'
+    end
   end
 end
diff --git a/spec/services/boards/lists/destroy_service_spec.rb b/spec/services/boards/lists/destroy_service_spec.rb
index bd98625b44f..3c4eb6b3fc5 100644
--- a/spec/services/boards/lists/destroy_service_spec.rb
+++ b/spec/services/boards/lists/destroy_service_spec.rb
@@ -2,37 +2,24 @@ require 'spec_helper'
 
 describe Boards::Lists::DestroyService do
   describe '#execute' do
-    let(:project) { create(:project) }
-    let(:board)   { create(:board, project: project) }
-    let(:user)    { create(:user) }
+    context 'when board parent is a project' do
+      let(:project) { create(:project) }
+      let(:board)   { create(:board, project: project) }
+      let(:user)    { create(:user) }
 
-    context 'when list type is label' do
-      it 'removes list from board' do
-        list = create(:list, board: board)
-        service = described_class.new(project, user)
+      let(:parent) { project }
 
-        expect { service.execute(list) }.to change(board.lists, :count).by(-1)
-      end
-
-      it 'decrements position of higher lists' do
-        development = create(:list, board: board, position: 0)
-        review      = create(:list, board: board, position: 1)
-        staging     = create(:list, board: board, position: 2)
-        closed      = board.closed_list
-
-        described_class.new(project, user).execute(development)
-
-        expect(review.reload.position).to eq 0
-        expect(staging.reload.position).to eq 1
-        expect(closed.reload.position).to be_nil
-      end
+      it_behaves_like 'lists destroy service'
     end
 
-    it 'does not remove list from board when list type is closed' do
-      list = board.closed_list
-      service = described_class.new(project, user)
+    context 'when board parent is a group' do
+      let(:group) { create(:group) }
+      let(:board)   { create(:board, group: group) }
+      let(:user)    { create(:user) }
+
+      let(:parent) { group }
 
-      expect { service.execute(list) }.not_to change(board.lists, :count)
+      it_behaves_like 'lists destroy service'
     end
   end
 end
diff --git a/spec/services/boards/lists/list_service_spec.rb b/spec/services/boards/lists/list_service_spec.rb
index b189857e4f4..24e04eed642 100644
--- a/spec/services/boards/lists/list_service_spec.rb
+++ b/spec/services/boards/lists/list_service_spec.rb
@@ -1,33 +1,25 @@
 require 'spec_helper'
 
 describe Boards::Lists::ListService do
-  let(:project) { create(:project) }
-  let(:board) { create(:board, project: project) }
-  let(:label) { create(:label, project: project) }
-  let!(:list) { create(:list, board: board, label: label) }
-  let(:service) { described_class.new(project, double) }
-
   describe '#execute' do
-    context 'when the board has a backlog list' do
-      let!(:backlog_list) { create(:backlog_list, board: board) }
-
-      it 'does not create a backlog list' do
-        expect { service.execute(board) }.not_to change(board.lists, :count)
-      end
+    context 'when board parent is a project' do
+      let(:project) { create(:project) }
+      let(:board) { create(:board, project: project) }
+      let(:label) { create(:label, project: project) }
+      let!(:list) { create(:list, board: board, label: label) }
+      let(:service) { described_class.new(project, double) }
 
-      it "returns board's lists" do
-        expect(service.execute(board)).to eq [backlog_list, list, board.closed_list]
-      end
+      it_behaves_like 'lists list service'
     end
 
-    context 'when the board does not have a backlog list' do
-      it 'creates a backlog list' do
-        expect { service.execute(board) }.to change(board.lists, :count).by(1)
-      end
+    context 'when board parent is a group' do
+      let(:group) { create(:group) }
+      let(:board) { create(:board, group: group) }
+      let(:label) { create(:group_label, group: group) }
+      let!(:list) { create(:list, board: board, label: label) }
+      let(:service) { described_class.new(group, double) }
 
-      it "returns board's lists" do
-        expect(service.execute(board)).to eq [board.backlog_list, list, board.closed_list]
-      end
+      it_behaves_like 'lists list service'
     end
   end
 end
diff --git a/spec/services/boards/lists/move_service_spec.rb b/spec/services/boards/lists/move_service_spec.rb
index a9d218bad49..16dfb2ae6af 100644
--- a/spec/services/boards/lists/move_service_spec.rb
+++ b/spec/services/boards/lists/move_service_spec.rb
@@ -2,100 +2,24 @@ require 'spec_helper'
 
 describe Boards::Lists::MoveService do
   describe '#execute' do
-    let(:project) { create(:project) }
-    let(:board)   { create(:board, project: project) }
-    let(:user)    { create(:user) }
+    context 'when board parent is a project' do
+      let(:project) { create(:project) }
+      let(:board)   { create(:board, project: project) }
+      let(:user)    { create(:user) }
 
-    let!(:planning)    { create(:list, board: board, position: 0) }
-    let!(:development) { create(:list, board: board, position: 1) }
-    let!(:review)      { create(:list, board: board, position: 2) }
-    let!(:staging)     { create(:list, board: board, position: 3) }
-    let!(:closed)      { create(:closed_list, board: board) }
+      let(:parent) { project }
 
-    context 'when list type is set to label' do
-      it 'keeps position of lists when new position is nil' do
-        service = described_class.new(project, user, position: nil)
-
-        service.execute(planning)
-
-        expect(current_list_positions).to eq [0, 1, 2, 3]
-      end
-
-      it 'keeps position of lists when new positon is equal to old position' do
-        service = described_class.new(project, user, position: planning.position)
-
-        service.execute(planning)
-
-        expect(current_list_positions).to eq [0, 1, 2, 3]
-      end
-
-      it 'keeps position of lists when new positon is negative' do
-        service = described_class.new(project, user, position: -1)
-
-        service.execute(planning)
-
-        expect(current_list_positions).to eq [0, 1, 2, 3]
-      end
-
-      it 'keeps position of lists when new positon is equal to number of labels lists' do
-        service = described_class.new(project, user, position: board.lists.label.size)
-
-        service.execute(planning)
-
-        expect(current_list_positions).to eq [0, 1, 2, 3]
-      end
-
-      it 'keeps position of lists when new positon is greater than number of labels lists' do
-        service = described_class.new(project, user, position: board.lists.label.size + 1)
-
-        service.execute(planning)
-
-        expect(current_list_positions).to eq [0, 1, 2, 3]
-      end
-
-      it 'increments position of intermediate lists when new positon is equal to first position' do
-        service = described_class.new(project, user, position: 0)
-
-        service.execute(staging)
-
-        expect(current_list_positions).to eq [1, 2, 3, 0]
-      end
-
-      it 'decrements position of intermediate lists when new positon is equal to last position' do
-        service = described_class.new(project, user, position: board.lists.label.last.position)
-
-        service.execute(planning)
-
-        expect(current_list_positions).to eq [3, 0, 1, 2]
-      end
-
-      it 'decrements position of intermediate lists when new position is greater than old position' do
-        service = described_class.new(project, user, position: 2)
-
-        service.execute(planning)
-
-        expect(current_list_positions).to eq [2, 0, 1, 3]
-      end
-
-      it 'increments position of intermediate lists when new position is lower than old position' do
-        service = described_class.new(project, user, position: 1)
-
-        service.execute(staging)
-
-        expect(current_list_positions).to eq [0, 2, 3, 1]
-      end
+      it_behaves_like 'lists move service'
     end
 
-    it 'keeps position of lists when list type is closed' do
-      service = described_class.new(project, user, position: 2)
+    context 'when board parent is a group' do
+      let(:group) { create(:group) }
+      let(:board)   { create(:board, group: group) }
+      let(:user)    { create(:user) }
 
-      service.execute(closed)
+      let(:parent) { group }
 
-      expect(current_list_positions).to eq [0, 1, 2, 3]
+      it_behaves_like 'lists move service'
     end
   end
-
-  def current_list_positions
-    [planning, development, review, staging].map { |list| list.reload.position }
-  end
 end
diff --git a/spec/support/shared_examples/services/boards/boards_create_service.rb b/spec/support/shared_examples/services/boards/boards_create_service.rb
new file mode 100644
index 00000000000..5bdc04f660f
--- /dev/null
+++ b/spec/support/shared_examples/services/boards/boards_create_service.rb
@@ -0,0 +1,27 @@
+shared_examples 'boards create service' do
+  context 'when parent does not have a board' do
+    it 'creates a new board' do
+      expect { service.execute }.to change(Board, :count).by(1)
+    end
+
+    it 'creates the default lists' do
+      board = service.execute
+
+      expect(board.lists.size).to eq 2
+      expect(board.lists.first).to be_backlog
+      expect(board.lists.last).to be_closed
+    end
+  end
+
+  context 'when parent has a board' do
+    before do
+      create(:board, parent: parent)
+    end
+
+    it 'does not create a new board' do
+      expect(service).to receive(:can_create_board?) { false }
+
+      expect { service.execute }.not_to change(parent.boards, :count)
+    end
+  end
+end
diff --git a/spec/support/shared_examples/services/boards/boards_list_service.rb b/spec/support/shared_examples/services/boards/boards_list_service.rb
new file mode 100644
index 00000000000..e0d5a7c61f2
--- /dev/null
+++ b/spec/support/shared_examples/services/boards/boards_list_service.rb
@@ -0,0 +1,29 @@
+shared_examples 'boards list service' do
+  context 'when parent does not have a board' do
+    it 'creates a new parent board' do
+      expect { service.execute }.to change(parent.boards, :count).by(1)
+    end
+
+    it 'delegates the parent board creation to Boards::CreateService' do
+      expect_any_instance_of(Boards::CreateService).to receive(:execute).once
+
+      service.execute
+    end
+  end
+
+  context 'when parent has a board' do
+    before do
+      create(:board, parent: parent)
+    end
+
+    it 'does not create a new board' do
+      expect { service.execute }.not_to change(parent.boards, :count)
+    end
+  end
+
+  it 'returns parent boards' do
+    board = create(:board, parent: parent)
+
+    expect(service.execute).to eq [board]
+  end
+end
diff --git a/spec/support/shared_examples/services/boards/issues_list_service.rb b/spec/support/shared_examples/services/boards/issues_list_service.rb
new file mode 100644
index 00000000000..3e744323cea
--- /dev/null
+++ b/spec/support/shared_examples/services/boards/issues_list_service.rb
@@ -0,0 +1,60 @@
+shared_examples 'issues list service' do
+  it 'delegates search to IssuesFinder' do
+    params = { board_id: board.id, id: list1.id }
+
+    expect_any_instance_of(IssuesFinder).to receive(:execute).once.and_call_original
+
+    described_class.new(parent, user, params).execute
+  end
+
+  context 'issues are ordered by priority' do
+    it 'returns opened issues when list_id is missing' do
+      params = { board_id: board.id }
+
+      issues = described_class.new(parent, user, params).execute
+
+      expect(issues).to eq [opened_issue2, reopened_issue1, opened_issue1]
+    end
+
+    it 'returns opened issues when listing issues from Backlog' do
+      params = { board_id: board.id, id: backlog.id }
+
+      issues = described_class.new(parent, user, params).execute
+
+      expect(issues).to eq [opened_issue2, reopened_issue1, opened_issue1]
+    end
+
+    it 'returns closed issues when listing issues from Closed' do
+      params = { board_id: board.id, id: closed.id }
+
+      issues = described_class.new(parent, user, params).execute
+
+      expect(issues).to eq [closed_issue4, closed_issue2, closed_issue5, closed_issue3, closed_issue1]
+    end
+
+    it 'returns opened issues that have label list applied when listing issues from a label list' do
+      params = { board_id: board.id, id: list1.id }
+
+      issues = described_class.new(parent, user, params).execute
+
+      expect(issues).to eq [list1_issue3, list1_issue1, list1_issue2]
+    end
+  end
+
+  context 'with list that does not belong to the board' do
+    it 'raises an error' do
+      list = create(:list)
+      service = described_class.new(parent, user, board_id: board.id, id: list.id)
+
+      expect { service.execute }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+  end
+
+  context 'with invalid list id' do
+    it 'raises an error' do
+      service = described_class.new(parent, user, board_id: board.id, id: nil)
+
+      expect { service.execute }.to raise_error(ActiveRecord::RecordNotFound)
+    end
+  end
+end
diff --git a/spec/support/shared_examples/services/boards/issues_move_service.rb b/spec/support/shared_examples/services/boards/issues_move_service.rb
new file mode 100644
index 00000000000..4a4fbaa3a0e
--- /dev/null
+++ b/spec/support/shared_examples/services/boards/issues_move_service.rb
@@ -0,0 +1,87 @@
+shared_examples 'issues move service' do
+  context 'when moving an issue between lists' do
+    let(:issue)  { create(:labeled_issue, project: project, labels: [bug, development]) }
+    let(:params) { { board_id: board1.id, from_list_id: list1.id, to_list_id: list2.id } }
+
+    it 'delegates the label changes to Issues::UpdateService' do
+      expect_any_instance_of(Issues::UpdateService).to receive(:execute).with(issue).once
+
+      described_class.new(parent, user, params).execute(issue)
+    end
+
+    it 'removes the label from the list it came from and adds the label of the list it goes to' do
+      described_class.new(parent, user, params).execute(issue)
+
+      expect(issue.reload.labels).to contain_exactly(bug, testing)
+    end
+  end
+
+  context 'when moving to closed' do
+    let!(:list3) { create(:list, board: board2, label: regression, position: 1) }
+
+    let(:issue)  { create(:labeled_issue, project: project, labels: [bug, development, testing, regression]) }
+    let(:params) { { board_id: board1.id, from_list_id: list2.id, to_list_id: closed.id } }
+
+    it 'delegates the close proceedings to Issues::CloseService' do
+      expect_any_instance_of(Issues::CloseService).to receive(:execute).with(issue).once
+
+      described_class.new(parent, user, params).execute(issue)
+    end
+
+    it 'removes all list-labels from boards and close the issue' do
+      described_class.new(parent, user, params).execute(issue)
+      issue.reload
+
+      expect(issue.labels).to contain_exactly(bug)
+      expect(issue).to be_closed
+    end
+  end
+
+  context 'when moving from closed' do
+    let(:issue)  { create(:labeled_issue, :closed, project: project, labels: [bug]) }
+    let(:params) { { board_id: board1.id, from_list_id: closed.id, to_list_id: list2.id } }
+
+    it 'delegates the re-open proceedings to Issues::ReopenService' do
+      expect_any_instance_of(Issues::ReopenService).to receive(:execute).with(issue).once
+
+      described_class.new(parent, user, params).execute(issue)
+    end
+
+    it 'adds the label of the list it goes to and reopen the issue' do
+      described_class.new(parent, user, params).execute(issue)
+      issue.reload
+
+      expect(issue.labels).to contain_exactly(bug, testing)
+      expect(issue).to be_opened
+    end
+  end
+
+  context 'when moving to same list' do
+    let(:issue)   { create(:labeled_issue, project: project, labels: [bug, development]) }
+    let(:issue1)  { create(:labeled_issue, project: project, labels: [bug, development]) }
+    let(:issue2)  { create(:labeled_issue, project: project, labels: [bug, development]) }
+    let(:params)  { { board_id: board1.id, from_list_id: list1.id, to_list_id: list1.id } }
+
+    it 'returns false' do
+      expect(described_class.new(parent, user, params).execute(issue)).to eq false
+    end
+
+    it 'keeps issues labels' do
+      described_class.new(parent, user, params).execute(issue)
+
+      expect(issue.reload.labels).to contain_exactly(bug, development)
+    end
+
+    it 'sorts issues' do
+      [issue, issue1, issue2].each do |issue|
+        issue.move_to_end && issue.save!
+      end
+
+      params.merge!(move_after_id: issue1.id, move_before_id: issue2.id)
+
+      described_class.new(parent, user, params).execute(issue)
+
+      expect(issue.relative_position).to be_between(issue1.relative_position, issue2.relative_position)
+    end
+  end
+end
diff --git a/spec/support/shared_examples/services/boards/lists_destroy_service.rb b/spec/support/shared_examples/services/boards/lists_destroy_service.rb
new file mode 100644
index 00000000000..62b6ffe1836
--- /dev/null
+++ b/spec/support/shared_examples/services/boards/lists_destroy_service.rb
@@ -0,0 +1,30 @@
+shared_examples 'lists destroy service' do
+  context 'when list type is label' do
+    it 'removes list from board' do
+      list = create(:list, board: board)
+      service = described_class.new(parent, user)
+
+      expect { service.execute(list) }.to change(board.lists, :count).by(-1)
+    end
+
+    it 'decrements position of higher lists' do
+      development = create(:list, board: board, position: 0)
+      review      = create(:list, board: board, position: 1)
+      staging     = create(:list, board: board, position: 2)
+      closed      = board.closed_list
+
+      described_class.new(parent, user).execute(development)
+
+      expect(review.reload.position).to eq 0
+      expect(staging.reload.position).to eq 1
+      expect(closed.reload.position).to be_nil
+    end
+  end
+
+  it 'does not remove list from board when list type is closed' do
+    list = board.closed_list
+    service = described_class.new(parent, user)
+
+    expect { service.execute(list) }.not_to change(board.lists, :count)
+  end
+end
diff --git a/spec/support/shared_examples/services/boards/lists_list_service.rb b/spec/support/shared_examples/services/boards/lists_list_service.rb
new file mode 100644
index 00000000000..0a8220111ab
--- /dev/null
+++ b/spec/support/shared_examples/services/boards/lists_list_service.rb
@@ -0,0 +1,23 @@
+shared_examples 'lists list service' do
+  context 'when the board has a backlog list' do
+    let!(:backlog_list) { create(:backlog_list, board: board) }
+
+    it 'does not create a backlog list' do
+      expect { service.execute(board) }.not_to change(board.lists, :count)
+    end
+
+    it "returns board's lists" do
+      expect(service.execute(board)).to eq [backlog_list, list, board.closed_list]
+    end
+  end
+
+  context 'when the board does not have a backlog list' do
+    it 'creates a backlog list' do
+      expect { service.execute(board) }.to change(board.lists, :count).by(1)
+    end
+
+    it "returns board's lists" do
+      expect(service.execute(board)).to eq [board.backlog_list, list, board.closed_list]
+    end
+  end
+end
diff --git a/spec/support/shared_examples/services/boards/lists_move_service.rb b/spec/support/shared_examples/services/boards/lists_move_service.rb
new file mode 100644
index 00000000000..07c98cb29b7
--- /dev/null
+++ b/spec/support/shared_examples/services/boards/lists_move_service.rb
@@ -0,0 +1,93 @@
+shared_examples 'lists move service' do
+  let!(:planning)    { create(:list, board: board, position: 0) }
+  let!(:development) { create(:list, board: board, position: 1) }
+  let!(:review)      { create(:list, board: board, position: 2) }
+  let!(:staging)     { create(:list, board: board, position: 3) }
+  let!(:closed)      { create(:closed_list, board: board) }
+
+  context 'when list type is set to label' do
+    it 'keeps position of lists when new position is nil' do
+      service = described_class.new(parent, user, position: nil)
+
+      service.execute(planning)
+
+      expect(current_list_positions).to eq [0, 1, 2, 3]
+    end
+
+    it 'keeps position of lists when new positon is equal to old position' do
+      service = described_class.new(parent, user, position: planning.position)
+
+      service.execute(planning)
+
+      expect(current_list_positions).to eq [0, 1, 2, 3]
+    end
+
+    it 'keeps position of lists when new positon is negative' do
+      service = described_class.new(parent, user, position: -1)
+
+      service.execute(planning)
+
+      expect(current_list_positions).to eq [0, 1, 2, 3]
+    end
+
+    it 'keeps position of lists when new positon is equal to number of labels lists' do
+      service = described_class.new(parent, user, position: board.lists.label.size)
+
+      service.execute(planning)
+
+      expect(current_list_positions).to eq [0, 1, 2, 3]
+    end
+
+    it 'keeps position of lists when new positon is greater than number of labels lists' do
+      service = described_class.new(parent, user, position: board.lists.label.size + 1)
+
+      service.execute(planning)
+
+      expect(current_list_positions).to eq [0, 1, 2, 3]
+    end
+
+    it 'increments position of intermediate lists when new positon is equal to first position' do
+      service = described_class.new(parent, user, position: 0)
+
+      service.execute(staging)
+
+      expect(current_list_positions).to eq [1, 2, 3, 0]
+    end
+
+    it 'decrements position of intermediate lists when new positon is equal to last position' do
+      service = described_class.new(parent, user, position: board.lists.label.last.position)
+
+      service.execute(planning)
+
+      expect(current_list_positions).to eq [3, 0, 1, 2]
+    end
+
+    it 'decrements position of intermediate lists when new position is greater than old position' do
+      service = described_class.new(parent, user, position: 2)
+
+      service.execute(planning)
+
+      expect(current_list_positions).to eq [2, 0, 1, 3]
+    end
+
+    it 'increments position of intermediate lists when new position is lower than old position' do
+      service = described_class.new(parent, user, position: 1)
+
+      service.execute(staging)
+
+      expect(current_list_positions).to eq [0, 2, 3, 1]
+    end
+  end
+
+  it 'keeps position of lists when list type is closed' do
+    service = described_class.new(parent, user, position: 2)
+
+    service.execute(closed)
+
+    expect(current_list_positions).to eq [0, 1, 2, 3]
+  end
+
+  def current_list_positions
+    [planning, development, review, staging].map { |list| list.reload.position }
+  end
+end
diff --git a/spec/views/layouts/nav/sidebar/_project.html.haml_spec.rb b/spec/views/layouts/nav/sidebar/_project.html.haml_spec.rb
index c5f455b8948..f28bf430f02 100644
--- a/spec/views/layouts/nav/sidebar/_project.html.haml_spec.rb
+++ b/spec/views/layouts/nav/sidebar/_project.html.haml_spec.rb
@@ -12,7 +12,7 @@ describe 'layouts/nav/sidebar/_project' do
   end
 
   describe 'issue boards' do
-    it 'has boards tab when multiple issue boards available' do
+    it 'has board tab' do
       render
 
       expect(rendered).to have_css('a[title="Board"]')