Merge branch 'weimeng-burndown-timezone' into 'master'

Make burndown chart timezone aware

Closes #4737

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

doc/api/group_milestones.md

@@ -136,3 +136,18 @@ Parameters:
 - `milestone_id` (required) - The ID of a group milestone
 
 [ce-12819]: https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/12819
+
+## Get all burndown chart events for a single milestone **[STARTER]**
+
+> [Introduced](https://gitlab.com/gitlab-org/gitlab-ee/issues/4737) in GitLab 12.1
+
+Get all burndown chart events for a single milestone.
+
+```
+GET /groups/:id/milestones/:milestone_id/burndown_events
+```
+
+Parameters:
+
+- `id` (required) - The ID or [URL-encoded path of the group](README.md#namespaced-path-encoding) owned by the authenticated user
+- `milestone_id` (required) - The ID of a group milestone

doc/api/milestones.md

@@ -147,3 +147,18 @@ Parameters:
 
 - `id` (required) - The ID or [URL-encoded path of the project](README.md#namespaced-path-encoding) owned by the authenticated user
 - `milestone_id` (required) - The ID of a project milestone
+
+## Get all burndown chart events for a single milestone **[STARTER]**
+
+> [Introduced](https://gitlab.com/gitlab-org/gitlab-ee/issues/4737) in GitLab 12.1
+
+Gets all burndown chart events for a single milestone.
+
+```
+GET /projects/:id/milestones/:milestone_id/burndown_events
+```
+
+Parameters:
+
+- `id` (required) - The ID or [URL-encoded path of the project](README.md#namespaced-path-encoding) owned by the authenticated user
+- `milestone_id` (required) - The ID of a project milestone

ee/app/assets/javascripts/burndown_chart/burndown_chart_data.js

+import dateFormat from 'dateformat';
+
+export default class BurndownChartData {
+  constructor(burndownEvents, startDate, dueDate) {
+    this.dateFormatMask = 'yyyy-mm-dd';
+    this.burndownEvents = this.convertEventsToLocalTimezone(burndownEvents);
+    this.startDate = startDate;
+    this.dueDate = dueDate;
+
+    // determine when to stop burndown chart
+    const today = dateFormat(new Date(), this.dateFormatMask);
+    this.endDate = today < this.dueDate ? today : this.dueDate;
+  }
+
+  generate() {
+    let openIssuesCount = 0;
+    let openIssuesWeight = 0;
+
+    const chartData = [];
+
+    for (
+      let date = new Date(this.startDate);
+      date <= new Date(this.endDate);
+      date.setDate(date.getDate() + 1)
+    ) {
+      const dateString = dateFormat(date, this.dateFormatMask);
+
+      const openedIssuesToday = this.filterAndSummarizeBurndownEvents(
+        event =>
+          event.created_at === dateString &&
+          (event.action === 'created' || event.action === 'reopened'),
+      );
+
+      const closedIssuesToday = this.filterAndSummarizeBurndownEvents(
+        event => event.created_at === dateString && event.action === 'closed',
+      );
+
+      openIssuesCount += openedIssuesToday.count - closedIssuesToday.count;
+      openIssuesWeight += openedIssuesToday.weight - closedIssuesToday.weight;
+
+      chartData.push([dateString, openIssuesCount, openIssuesWeight]);
+    }
+
+    return chartData;
+  }
+
+  convertEventsToLocalTimezone(events) {
+    return events.map(event => ({
+      ...event,
+      created_at: dateFormat(event.created_at, this.dateFormatMask),
+    }));
+  }
+
+  filterAndSummarizeBurndownEvents(filter) {
+    const issues = this.burndownEvents.filter(filter);
+
+    return {
+      count: issues.length,
+      weight: issues.reduce((total, issue) => total + issue.weight, 0),
+    };
+  }
+}

ee/app/assets/javascripts/burndown_chart/index.js

 import $ from 'jquery';
 import Cookies from 'js-cookie';
 import BurndownChart from './burndown_chart';
+import BurndownChartData from './burndown_chart_data';
+import Flash from '~/flash';
+import axios from '~/lib/utils/axios_utils';
 import { s__ } from '~/locale';
 
 export default () => {
@@ -13,49 +16,61 @@ export default () => {
 
   // generate burndown chart (if data available)
   const container = '.burndown-chart';
-  const $chartElm = $(container);
-
-  if ($chartElm.length) {
-    const startDate = $chartElm.data('startDate');
-    const dueDate = $chartElm.data('dueDate');
-    const chartData = $chartElm.data('chartData');
-    const openIssuesCount = chartData.map(d => [d[0], d[1]]);
-    const openIssuesWeight = chartData.map(d => [d[0], d[2]]);
-
-    const chart = new BurndownChart({ container, startDate, dueDate });
-
-    let currentView = 'count';
-    chart.setData(openIssuesCount, { label: s__('BurndownChartLabel|Open issues'), animate: true });
-
-    $('.js-burndown-data-selector').on('click', 'button', function switchData() {
-      const $this = $(this);
-      const show = $this.data('show');
-      if (currentView !== show) {
-        currentView = show;
-        $this
-          .removeClass('btn-inverted')
-          .siblings()
-          .addClass('btn-inverted');
-        switch (show) {
-          case 'count':
-            chart.setData(openIssuesCount, {
-              label: s__('BurndownChartLabel|Open issues'),
-              animate: true,
-            });
-            break;
-          case 'weight':
-            chart.setData(openIssuesWeight, {
-              label: s__('BurndownChartLabel|Open issue weight'),
-              animate: true,
-            });
-            break;
-          default:
-            break;
-        }
-      }
-    });
-
-    window.addEventListener('resize', () => chart.animateResize(1));
-    $(document).on('click', '.js-sidebar-toggle', () => chart.animateResize(2));
+  const $chartEl = $(container);
+
+  if ($chartEl.length) {
+    const startDate = $chartEl.data('startDate');
+    const dueDate = $chartEl.data('dueDate');
+    const burndownEventsPath = $chartEl.data('burndownEventsPath');
+
+    axios
+      .get(burndownEventsPath)
+      .then(response => {
+        const burndownEvents = response.data;
+        const chartData = new BurndownChartData(burndownEvents, startDate, dueDate).generate();
+
+        const openIssuesCount = chartData.map(d => [d[0], d[1]]);
+        const openIssuesWeight = chartData.map(d => [d[0], d[2]]);
+
+        const chart = new BurndownChart({ container, startDate, dueDate });
+
+        let currentView = 'count';
+        chart.setData(openIssuesCount, {
+          label: s__('BurndownChartLabel|Open issues'),
+          animate: true,
+        });
+
+        $('.js-burndown-data-selector').on('click', 'button', function switchData() {
+          const $this = $(this);
+          const show = $this.data('show');
+          if (currentView !== show) {
+            currentView = show;
+            $this
+              .removeClass('btn-inverted')
+              .siblings()
+              .addClass('btn-inverted');
+            switch (show) {
+              case 'count':
+                chart.setData(openIssuesCount, {
+                  label: s__('BurndownChartLabel|Open issues'),
+                  animate: true,
+                });
+                break;
+              case 'weight':
+                chart.setData(openIssuesWeight, {
+                  label: s__('BurndownChartLabel|Open issue weight'),
+                  animate: true,
+                });
+                break;
+              default:
+                break;
+            }
+          }
+        });
+
+        window.addEventListener('resize', () => chart.animateResize(1));
+        $(document).on('click', '.js-sidebar-toggle', () => chart.animateResize(2));
+      })
+      .catch(() => new Flash('Error loading burndown chart data'));
   }
 };

ee/app/models/burndown.rb

@@ -3,23 +3,8 @@
 class Burndown
   include Gitlab::Utils::StrongMemoize
 
-  class Issue
-    attr_reader :closed_at, :weight, :state
-
-    def initialize(closed_at, weight, state)
-      @closed_at = closed_at
-      @weight = weight
-      @state = state
-    end
-
-    def reopened?
-      @state == 'opened' && @closed_at.present?
-    end
-  end
-
-  attr_reader :start_date, :due_date, :end_date, :accurate, :legacy_data, :milestone, :current_user
+  attr_reader :start_date, :due_date, :end_date, :accurate, :milestone, :current_user
   alias_method :accurate?, :accurate
-  alias_method :empty?, :legacy_data
 
   def initialize(milestone, current_user)
     @milestone = milestone
@@ -29,132 +14,97 @@ class Burndown
     @end_date = @milestone.due_date
     @end_date = Date.today if @end_date.present? && @end_date > Date.today
 
-    @accurate = milestone_issues.all?(&:closed_at)
-    @legacy_data = milestone_issues.any? && milestone_issues.none?(&:closed_at)
+    @accurate = true
   end
 
-  # Returns the chart data in the following format:
-  # [date, issue count, issue weight] eg: [["2017-03-01", 33, 127], ["2017-03-02", 35, 73], ["2017-03-03", 28, 50]...]
+  # Returns an array of milestone issue event data in the following format:
+  # [{"created_at":"2019-03-10T16:00:00.039Z", "weight":null, "action":"closed" }, ... ]
   def as_json(opts = nil)
     return [] unless valid?
 
-    open_issues_count = 0
-    open_issues_weight = 0
-
-    start_date.upto(end_date).each_with_object([]) do |date, chart_data|
-      closed, reopened = closed_and_reopened_issues_by(date)
-
-      closed_issues_count = closed.count
-      closed_issues_weight = sum_issues_weight(closed)
-
-      issues_created = opened_issues_on(date)
-      open_issues_count += issues_created.count
-      open_issues_weight += sum_issues_weight(issues_created)
-
-      open_issues_count -= closed_issues_count
-      open_issues_weight -= closed_issues_weight
-
-      chart_data << [date.strftime("%Y-%m-%d"), open_issues_count, open_issues_weight]
-
-      reopened_count = reopened.count
-      reopened_weight = sum_issues_weight(reopened)
+    burndown_events
+  end
 
-      open_issues_count += reopened_count
-      open_issues_weight += reopened_weight
-    end
+  def empty?
+    burndown_events.any? && legacy_data?
   end
 
   def valid?
     start_date && due_date
   end
 
+  # If all closed issues have no closed events, mark burndown chart as containing legacy data
+  def legacy_data?
+    strong_memoize(:legacy_data) do
+      closed_events = milestone_issues.select(&:closed?)
+      closed_events.any? && !Event.closed.where(target: closed_events, action: Event::CLOSED).exists?
+    end
+  end
+
   private
 
-  def opened_issues_on(date)
-    return {} if opened_issues_grouped_by_date.empty?
+  def burndown_events
+    milestone_issues
+      .map { |issue| burndown_events_for(issue) }
+      .flatten
+  end
 
-    date = date.to_date
+  def burndown_events_for(issue)
+    [
+      transformed_create_event_for(issue),
+      transformed_action_events_for(issue),
+      transformed_legacy_closed_event_for(issue)
+    ].compact
+  end
+
+  def milestone_issues
+    return [] unless valid?
 
-    # If issues.created_at < milestone.start_date
-    # we consider all of them created at milestone.start_date
-    if date == start_date
-      first_issue_created_at = opened_issues_grouped_by_date.keys.first
-      days_before_start_date = start_date.downto(first_issue_created_at).to_a
-      opened_issues_grouped_by_date.values_at(*days_before_start_date).flatten.compact
-    else
-      opened_issues_grouped_by_date[date] || []
+    strong_memoize(:milestone_issues) do
+      @milestone
+        .issues_visible_to_user(current_user)
+        .where('issues.created_at <= ?', end_date.end_of_day)
     end
   end
 
-  def opened_issues_grouped_by_date
-    strong_memoize(:opened_issues_grouped_by_date) do
-      issues =
-        @milestone
-          .issues_visible_to_user(current_user)
-          .where('issues.created_at <= ?', end_date)
-          .reorder(nil)
-          .order('issues.created_at').to_a
-
-      issues.group_by do |issue|
-        issue.created_at.to_date
-      end
+  def milestone_events_per_issue
+    return [] unless valid?
+
+    strong_memoize(:milestone_events_per_issue) do
+      Event
+        .where(target: milestone_issues, action: [Event::CLOSED, Event::REOPENED])
+        .where('created_at <= ?', end_date.end_of_day)
+        .group_by(&:target_id)
     end
   end
 
-  def sum_issues_weight(issues)
-    issues.map(&:weight).compact.sum
+  # Use issue creation date as the source of truth for created events
+  def transformed_create_event_for(issue)
+    build_burndown_event(issue.created_at, issue.weight, 'created')
   end
 
-  def closed_and_reopened_issues_by(date)
-    current_date = date.to_date
+  # Use issue events as the source of truth for events other than 'created'
+  def transformed_action_events_for(issue)
+    events_for_issue = milestone_events_per_issue[issue.id]
+    return [] unless events_for_issue
 
-    closed =
-      milestone_issues.select do |issue|
-        (issue.closed_at&.to_date || start_date) == current_date
-      end
+    events_for_issue.map do |event|
+      build_burndown_event(event.created_at, issue.weight, Event::ACTIONS.key(event.action).to_s)
+    end
+  end
+
+  # If issue is closed but has no closed events, treat it as though closed on milestone start date
+  def transformed_legacy_closed_event_for(issue)
+    return [] unless issue.closed?
+    return [] if milestone_events_per_issue[issue.id]&.any?(&:closed_action?)
 
-    reopened = closed.select(&:reopened?)
+    # Mark burndown chart as inaccurate
+    @accurate = false
 
-    [closed, reopened]
+    build_burndown_event(milestone.start_date.beginning_of_day, issue.weight, 'closed')
   end
 
-  def milestone_issues
-    @milestone_issues ||=
-      begin
-        # We make use of `events` table to get the closed_at timestamp.
-        # `issues.closed_at` can't be used once it's nullified if the issue is
-        # reopened.
-        internal_clause =
-          @milestone.issues_visible_to_user(current_user)
-            .joins("LEFT OUTER JOIN events e ON issues.id = e.target_id AND e.target_type = 'Issue' AND e.action = #{Event::CLOSED}")
-            .where("state = 'closed' OR (state = 'opened' AND e.action = #{Event::CLOSED})") # rubocop:disable GitlabSecurity/SqlInjection
-
-        rel =
-          if Gitlab::Database.postgresql?
-            ::Issue
-              .select("*")
-              .from(internal_clause.select('DISTINCT ON (issues.id) issues.id, issues.state, issues.weight, e.created_at AS closed_at'))
-              .order('closed_at ASC')
-              .pluck('closed_at, weight, state')
-          else
-            # In rails 5 mysql's `only_full_group_by` option is enabled by default,
-            # this means that `GROUP` clause must include all columns used in `SELECT`
-            # clause. Adding all columns to `GROUP` means that we have now
-            # duplicates (by issue ID) in records. To get rid of these, we unify them
-            # on ruby side by issue id. Finally we drop the issue id attribute from records
-            # because this is not accepted when creating Issue object.
-            ::Issue
-              .select("*")
-              .from(internal_clause.select('issues.id, issues.state, issues.weight, e.created_at AS closed_at'))
-              .group(:id, :closed_at, :weight, :state)
-              .having('closed_at = MIN(closed_at) OR closed_at IS NULL')
-              .order('closed_at ASC')
-              .pluck('id, closed_at, weight, state')
-              .uniq(&:first)
-              .map { |attrs| attrs.drop(1) }
-          end
-
-        rel.map { |attrs| Issue.new(*attrs) }
-      end
+  def build_burndown_event(created_at, issue_weight, action)
+    { created_at: created_at, weight: issue_weight, action: action }
   end
 end

ee/app/views/shared/milestones/_burndown.html.haml

 - milestone = local_assigns[:milestone]
 - burndown = burndown_chart(milestone)
 - warning = data_warning_for(burndown)
+- burndown_endpoint = milestone.group_milestone? ? api_v4_groups_milestones_burndown_events_path(id: milestone.group.id, milestone_id: milestone.id) : api_v4_projects_milestones_burndown_events_path(id: milestone.project.id, milestone_id: milestone.milestoneish_id)
 
 = warning
 
@@ -13,7 +14,9 @@
           Issues
         %button.btn.btn-sm.btn-primary.btn-inverted{ data: { show: 'weight' } }
           Issue weight
-  .burndown-chart{ data: { start_date: burndown.start_date.strftime("%Y-%m-%d"), due_date: burndown.due_date.strftime("%Y-%m-%d"), chart_data: burndown.to_json } }
+  .burndown-chart{ data: { start_date: burndown.start_date.strftime("%Y-%m-%d"),
+    due_date: burndown.due_date.strftime("%Y-%m-%d"),
+    burndown_events_path: expose_url(burndown_endpoint) } }
 
 - elsif show_burndown_placeholder?(milestone, warning)
   .burndown-hint.content-block.container-fluid

ee/changelogs/unreleased/weimeng-burndown-timezone.yml

+---
+title: Make burndown chart timezone aware
+merge_request: 10328
+author:
+type: fixed

ee/lib/ee/api/group_milestones.rb

+# frozen_string_literal: true
+
+module EE
+  module API
+    module GroupMilestones
+      extend ActiveSupport::Concern
+
+      prepended do
+        include EE::API::MilestoneResponses # rubocop: disable Cop/InjectEnterpriseEditionModule
+
+        params do
+          requires :id, type: String, desc: 'The ID of a group'
+        end
+        resource :groups, requirements: ::API::API::NAMESPACE_OR_PROJECT_REQUIREMENTS do
+          desc 'Get a list of burndown events' do
+            detail 'This feature was introduced in GitLab 12.1.'
+          end
+          get ':id/milestones/:milestone_id/burndown_events' do
+            authorize! :read_group, user_group
+
+            milestone_burndown_events_for(user_group)
+          end
+        end
+      end
+    end
+  end
+end

ee/lib/ee/api/milestone_responses.rb

+# frozen_string_literal: true
+
+module EE
+  module API
+    module MilestoneResponses
+      extend ActiveSupport::Concern
+
+      included do
+        helpers do
+          def milestone_burndown_events_for(parent)
+            milestone = parent.milestones.find(params[:milestone_id])
+
+            if milestone.supports_burndown_charts?
+              present Burndown.new(milestone, current_user).as_json
+            else
+              render_api_error!("Milestone does not support burndown chart", 405)
+            end
+          end
+        end
+      end
+    end
+  end
+end

ee/lib/ee/api/project_milestones.rb

+# frozen_string_literal: true
+
+module EE
+  module API
+    module ProjectMilestones
+      extend ActiveSupport::Concern
+
+      prepended do
+        include EE::API::MilestoneResponses # rubocop: disable Cop/InjectEnterpriseEditionModule
+
+        params do
+          requires :id, type: String, desc: 'The ID of a project'
+        end
+        resource :projects, requirements: ::API::API::NAMESPACE_OR_PROJECT_REQUIREMENTS do
+          desc 'Get a list of burndown events' do
+            detail 'This feature was introduced in GitLab 12.1.'
+          end
+          get ':id/milestones/:milestone_id/burndown_events' do
+            authorize! :read_milestone, user_project
+
+            milestone_burndown_events_for(user_project)
+          end
+        end
+      end
+    end
+  end
+end

ee/spec/frontend/burndown_chart/burndown_chart_data_spec.js

+import dateFormat from 'dateformat';
+import BurndownChartData from 'ee/burndown_chart/burndown_chart_data';
+
+describe('BurndownChartData', () => {
+  const milestoneEvents = [
+    { created_at: '2017-03-01T00:00:00.000Z', weight: 2, action: 'created' },
+    { created_at: '2017-03-01T00:00:00.000Z', weight: 2, action: 'created' },
+    { created_at: '2017-03-01T00:00:00.000Z', weight: 2, action: 'created' },
+    { created_at: '2017-03-01T00:00:00.000Z', weight: 2, action: 'created' },
+    { created_at: '2017-03-01T00:00:00.000Z', weight: 2, action: 'created' },
+    { created_at: '2017-03-01T00:00:00.190Z', weight: 2, action: 'closed' },
+    { created_at: '2017-03-01T00:00:00.478Z', weight: 2, action: 'reopened' },
+    { created_at: '2017-03-01T00:00:00.597Z', weight: 2, action: 'closed' },
+    { created_at: '2017-03-01T00:00:00.767Z', weight: 2, action: 'reopened' },
+    { created_at: '2017-03-03T00:00:00.260Z', weight: 2, action: 'closed' },
+    { created_at: '2017-03-03T00:00:00.152Z', weight: 2, action: 'closed' },
+    { created_at: '2017-03-03T00:00:00.572Z', weight: 2, action: 'reopened' },
+    { created_at: '2017-03-03T00:00:00.450Z', weight: 2, action: 'closed' },
+    { created_at: '2017-03-03T00:00:00.352Z', weight: 2, action: 'reopened' },
+  ];
+  const startDate = '2017-03-01';
+  const dueDate = '2017-03-03';
+
+  let burndownChartData;
+
+  beforeEach(() => {
+    burndownChartData = new BurndownChartData(milestoneEvents, startDate, dueDate);
+  });
+
+  describe('generate', () => {
+    it('generates an array of arrays with date, issue count and weight', () => {
+      expect(burndownChartData.generate()).toEqual([
+        ['2017-03-01', 5, 10],
+        ['2017-03-02', 5, 10],
+        ['2017-03-03', 4, 8],
+      ]);
+    });
+
+    describe('when viewing before due date', () => {
+      beforeAll(() => {
+        const today = new Date(2017, 2, 2);
+
+        // eslint-disable-next-line no-global-assign
+        Date = class extends Date {
+          constructor(date) {
+            super(date || today);
+          }
+        };
+      });
+
+      it('counts until today if milestone due date > date today', () => {
+        const chartData = burndownChartData.generate();
+        expect(dateFormat(new Date(), 'yyyy-mm-dd')).toEqual('2017-03-02');
+        expect(chartData[chartData.length - 1][0]).toEqual('2017-03-02');
+      });
+    });
+  });
+});

ee/spec/requests/api/group_milestones_spec.rb

@@ -8,12 +8,13 @@ describe API::GroupMilestones do
   let(:project) { create(:project, namespace: group) }
   let!(:group_member) { create(:group_member, group: group, user: user) }
   let!(:closed_milestone) { create(:closed_milestone, group: group, title: 'version1', description: 'closed milestone') }
-  let!(:milestone) { create(:milestone, group: group, title: 'version2', description: 'open milestone') }
+  let!(:milestone) { create(:milestone, group: group, title: 'version2', description: 'open milestone', start_date: Date.today, due_date: Date.today + 3.days) }
+  let(:issue) { create(:issue, created_at: Date.today.beginning_of_day, weight: 2, project: project) }
   let(:issues_route) { "/groups/#{group.id}/milestones/#{milestone.id}/issues" }
 
   before do
     project.add_developer(user)
-    milestone.issues << create(:issue, project: project)
+    milestone.issues << issue
   end
 
   it 'matches V4 EE-specific  response schema for a list of issues' do
@@ -22,4 +23,8 @@ describe API::GroupMilestones do
     expect(response).to have_gitlab_http_status(200)
     expect(response).to match_response_schema('public_api/v4/issues', dir: 'ee')
   end
+
+  it_behaves_like 'group and project milestone burndowns', '/groups/:id/milestones/:milestone_id/burndown_events' do
+    let(:route) { "/groups/#{group.id}/milestones" }
+  end
 end

ee/spec/requests/api/project_milestones_spec.rb

@@ -5,12 +5,13 @@ require 'spec_helper'
 describe API::ProjectMilestones do
   let(:user) { create(:user) }
   let!(:project) { create(:project, namespace: user.namespace ) }
-  let!(:milestone) { create(:milestone, project: project, title: 'version2', description: 'open milestone') }
+  let!(:milestone) { create(:milestone, project: project, title: 'version2', description: 'open milestone', start_date: Date.today, due_date: Date.today + 3.days) }
+  let(:issue) { create(:issue, created_at: Date.today.beginning_of_day, weight: 2, project: project) }
   let(:issues_route) { "/projects/#{project.id}/milestones/#{milestone.id}/issues" }
 
   before do
     project.add_developer(user)
-    milestone.issues << create(:issue, project: project)
+    milestone.issues << issue
   end
 
   it 'matches V4 EE-specific response schema for a list of issues' do
@@ -19,4 +20,8 @@ describe API::ProjectMilestones do
     expect(response).to have_gitlab_http_status(200)
     expect(response).to match_response_schema('public_api/v4/issues', dir: 'ee')
   end
+
+  it_behaves_like 'group and project milestone burndowns', '/projects/:id/milestones/:milestone_id/burndown_events' do
+    let(:route) { "/projects/#{project.id}/milestones" }
+  end
 end

ee/spec/support/shared_examples/milestone_burndown_shared_examples.rb

+# frozen_string_literal: true
+
+shared_examples_for 'group and project milestone burndowns' do |route_definition|
+  let(:resource_route) { "#{route}/#{milestone.id}/burndown_events" }
+
+  describe "GET #{route_definition}" do
+    it 'returns burndown events list' do
+      get api(resource_route, user)
+
+      expect(response).to have_gitlab_http_status(200)
+      expect(json_response).to be_an Array
+      expect(json_response.first['created_at'].to_time).to eq(Date.today.beginning_of_day)
+      expect(json_response.first['weight']).to eq(2)
+      expect(json_response.first['action']).to eq('created')
+    end
+
+    it 'returns 404 when user is not authorized to read milestone' do
+      outside_user = create(:user)
+
+      get api(resource_route, outside_user)
+
+      expect(response).to have_gitlab_http_status(404)
+    end
+  end
+end

lib/api/group_milestones.rb

@@ -95,3 +95,5 @@ module API
     end
   end
 end
+
+API::GroupMilestones.prepend(EE::API::GroupMilestones)

lib/api/project_milestones.rb

@@ -116,3 +116,5 @@ module API
     end
   end
 end
+
+API::ProjectMilestones.prepend(EE::API::ProjectMilestones)