Fix other spec failures

app/controllers/concerns/cycle_analytics_params.rb

 module CycleAnalyticsParams
   extend ActiveSupport::Concern
 
-  def options
-    @options ||= { from: start_date(events_params), current_user: current_user }
+  def options(params)
+    @options ||= { from: start_date(params), current_user: current_user }
   end
 
   def start_date(params)

app/controllers/projects/cycle_analytics/events_controller.rb

@@ -9,46 +9,46 @@ module Projects
       before_action :authorize_read_merge_request!, only: [:code, :review]
 
       def issue
-        render_events(events.issue_events)
+        render_events(cycle_analytics.events_for(:issue))
       end
     
       def plan
-        render_events(events.plan_events)
+        render_events(cycle_analytics.events_for(:plan))
       end
     
       def code
-        render_events(events.code_events)
+        render_events(cycle_analytics.events_for(:code))
       end
     
       def test
-        options[:branch] = events_params[:branch_name]
+        options(events_params)[:branch] = events_params[:branch_name]
     
-        render_events(events.test_events)
+        render_events(cycle_analytics.events_for(:test))
       end
     
       def review
-        render_events(events.review_events)
+        render_events(cycle_analytics.events_for(:review))
       end
     
       def staging
-        render_events(events.staging_events)
+        render_events(cycle_analytics.events_for(:staging))
       end
     
       def production
-        render_events(events.production_events)
+        render_events(cycle_analytics.events_for(:production))
       end
     
       private
 
-      def render_events(events_list)
+      def render_events(events)
         respond_to do |format|
           format.html
-          format.json { render json: { events: events_list } }
+          format.json { render json: { events: events } }
         end
       end
     
-      def events
-        @events ||= Gitlab::CycleAnalytics::Events.new(project: project, options: options)
+      def cycle_analytics
+        @cycle_analytics ||= ::CycleAnalytics.new(project, options: options(events_params))
       end
     
       def events_params

app/controllers/projects/cycle_analytics_controller.rb

@@ -6,7 +6,7 @@ class Projects::CycleAnalyticsController < Projects::ApplicationController
   before_action :authorize_read_cycle_analytics!
 
   def show
-    @cycle_analytics = ::CycleAnalytics.new(@project, options: options)
+    @cycle_analytics = ::CycleAnalytics.new(@project, options: options(cycle_analytics_params))
 
     @cycle_analytics_no_data = @cycle_analytics.no_stats?
 
@@ -21,7 +21,7 @@ class Projects::CycleAnalyticsController < Projects::ApplicationController
   def cycle_analytics_params
     return {} unless params[:cycle_analytics].present?
 
-    { start_date: params[:cycle_analytics][:start_date] }
+    params[:cycle_analytics].slice(:start_date)
   end
 
   def cycle_analytics_json

app/models/cycle_analytics.rb

@@ -7,7 +7,7 @@ class CycleAnalytics
   end
 
   def summary
-    @summary ||= Gitlab::CycleAnalytics::Summary.new(@project, from: @options[:from]).data
+    @summary ||= ::Gitlab::CycleAnalytics::StageSummary.new(@project, from: @options[:from]).data
   end
 
   def stats
@@ -15,23 +15,26 @@ class CycleAnalytics
   end
 
   def no_stats?
-    stats.map(&:value).compact.empty?
+    stats.map { |hash| hash[:value] }.compact.empty?
   end
 
   def permissions(user:)
     Gitlab::CycleAnalytics::Permissions.get(user: user, project: @project)
   end
 
+  def events_for(stage)
+    classify_stage(stage).new(project: @project, options: @options, stage: stage).events
+  end
+
   private
 
   def stats_per_stage
     STAGES.map do |stage_name|
-      classify_stage(method_sym).new(project: @project, options: @options, stage: stage_name).median_data
+      classify_stage(stage_name).new(project: @project, options: @options, stage: stage_name).median_data
     end
   end
 
   def classify_stage(stage_name)
     "Gitlab::CycleAnalytics::#{stage_name.to_s.capitalize}Stage".constantize
   end
-
 end

lib/gitlab/cycle_analytics/base_event.rb

@@ -5,10 +5,11 @@ module Gitlab
 
       attr_reader :stage, :start_time_attrs, :end_time_attrs, :projections, :query
 
-      def initialize(fetcher:, stage:)
+      def initialize(fetcher:, stage:, options:)
         @query = EventsQuery.new(fetcher: fetcher)
         @project = fetcher.project
         @stage = stage
+        @options = options
       end
 
       def fetch

lib/gitlab/cycle_analytics/base_stage.rb

@@ -13,7 +13,7 @@ module Gitlab
       end
 
       def events
-        event_class.new(fetcher: @fetcher, stage: @stage).fetch
+        event_class.new(fetcher: @fetcher, stage: @stage, options: @options).fetch
       end
 
       def median_data

lib/gitlab/cycle_analytics/events.rb

-module Gitlab
-  module CycleAnalytics
-    class Events
-      def initialize(project:, options:)
-        @project = project
-        @options = options
-      end
-
-      def issue_events
-        IssueEvent.new(project: @project, options: @options).fetch
-      end
-
-      def plan_events
-        PlanEvent.new(project: @project, options: @options).fetch
-      end
-
-      def code_events
-        CodeEvent.new(project: @project, options: @options).fetch
-      end
-
-      def test_events
-        TestEvent.new(project: @project, options: @options).fetch
-      end
-
-      def review_events
-        ReviewEvent.new(project: @project, options: @options).fetch
-      end
-
-      def staging_events
-        StagingEvent.new(project: @project, options: @options).fetch
-      end
-
-      def production_events
-        ProductionEvent.new(project: @project, options: @options).fetch
-      end
-    end
-  end
-end

lib/gitlab/cycle_analytics/summary.rb → lib/gitlab/cycle_analytics/stage_summary.rb

 module Gitlab
   module CycleAnalytics
-    module Summary
-      extend self
-
+    class StageSummary
       def initialize(project, from:)
         @project = project
         @from = from

lib/gitlab/cycle_analytics/summary/base.rb

@@ -8,7 +8,7 @@ module Gitlab
         end
 
         def title
-          self.name
+          self.class.name.demodulize
         end
 
         def value

spec/lib/gitlab/cycle_analytics/code_event_spec.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 require 'lib/gitlab/cycle_analytics/shared_event_spec'
 
 describe Gitlab::CycleAnalytics::CodeEvent do
+  let(:stage_name) { :code }
+
   it_behaves_like 'default query config' do
     it 'does not have the default order' do
       expect(event.order).not_to eq(event.start_time_attrs)

spec/lib/gitlab/cycle_analytics/events_spec.rb

 require 'spec_helper'
 
-describe Gitlab::CycleAnalytics::Events do
+describe 'cycle analytics events' do
   let(:project) { create(:project) }
   let(:from_date) { 10.days.ago }
   let(:user) { create(:user, :admin) }
   let!(:context) { create(:issue, project: project, created_at: 2.days.ago) }
 
-  subject { described_class.new(project: project, options: { from: from_date, current_user: user }) }
+  let(:events) do
+    CycleAnalytics.new(project, options: { from: from_date, current_user: user }).events_for(stage)
+  end
 
   before do
     allow_any_instance_of(Gitlab::ReferenceExtractor).to receive(:issues).and_return([context])
@@ -15,104 +17,112 @@ describe Gitlab::CycleAnalytics::Events do
   end
 
   describe '#issue_events' do
+    let(:stage) { :issue }
+
     it 'has the total time' do
-      expect(subject.issue_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
 
     it 'has a title' do
-      expect(subject.issue_events.first[:title]).to eq(context.title)
+      expect(events.first[:title]).to eq(context.title)
     end
 
     it 'has the URL' do
-      expect(subject.issue_events.first[:url]).not_to be_nil
+      expect(events.first[:url]).not_to be_nil
     end
 
     it 'has an iid' do
-      expect(subject.issue_events.first[:iid]).to eq(context.iid.to_s)
+      expect(events.first[:iid]).to eq(context.iid.to_s)
     end
 
     it 'has a created_at timestamp' do
-      expect(subject.issue_events.first[:created_at]).to end_with('ago')
+      expect(events.first[:created_at]).to end_with('ago')
     end
 
     it "has the author's URL" do
-      expect(subject.issue_events.first[:author][:web_url]).not_to be_nil
+      expect(events.first[:author][:web_url]).not_to be_nil
     end
 
     it "has the author's avatar URL" do
-      expect(subject.issue_events.first[:author][:avatar_url]).not_to be_nil
+      expect(events.first[:author][:avatar_url]).not_to be_nil
     end
 
     it "has the author's name" do
-      expect(subject.issue_events.first[:author][:name]).to eq(context.author.name)
+      expect(events.first[:author][:name]).to eq(context.author.name)
     end
   end
 
   describe '#plan_events' do
+    let(:stage) { :plan }
+
     it 'has a title' do
-      expect(subject.plan_events.first[:title]).not_to be_nil
+      expect(events.first[:title]).not_to be_nil
     end
 
     it 'has a sha short ID' do
-      expect(subject.plan_events.first[:short_sha]).not_to be_nil
+      expect(events.first[:short_sha]).not_to be_nil
     end
 
     it 'has the URL' do
-      expect(subject.plan_events.first[:commit_url]).not_to be_nil
+      expect(events.first[:commit_url]).not_to be_nil
     end
 
     it 'has the total time' do
-      expect(subject.plan_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
 
     it "has the author's URL" do
-      expect(subject.plan_events.first[:author][:web_url]).not_to be_nil
+      expect(events.first[:author][:web_url]).not_to be_nil
     end
 
     it "has the author's avatar URL" do
-      expect(subject.plan_events.first[:author][:avatar_url]).not_to be_nil
+      expect(events.first[:author][:avatar_url]).not_to be_nil
     end
 
     it "has the author's name" do
-      expect(subject.plan_events.first[:author][:name]).not_to be_nil
+      expect(events.first[:author][:name]).not_to be_nil
     end
   end
 
   describe '#code_events' do
+    let(:stage) { :code }
+
     before do
       create_commit_referencing_issue(context)
     end
 
     it 'has the total time' do
-      expect(subject.code_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
 
     it 'has a title' do
-      expect(subject.code_events.first[:title]).to eq('Awesome merge_request')
+      expect(events.first[:title]).to eq('Awesome merge_request')
     end
 
     it 'has an iid' do
-      expect(subject.code_events.first[:iid]).to eq(context.iid.to_s)
+      expect(events.first[:iid]).to eq(context.iid.to_s)
     end
 
     it 'has a created_at timestamp' do
-      expect(subject.code_events.first[:created_at]).to end_with('ago')
+      expect(events.first[:created_at]).to end_with('ago')
     end
 
     it "has the author's URL" do
-      expect(subject.code_events.first[:author][:web_url]).not_to be_nil
+      expect(events.first[:author][:web_url]).not_to be_nil
     end
 
     it "has the author's avatar URL" do
-      expect(subject.code_events.first[:author][:avatar_url]).not_to be_nil
+      expect(events.first[:author][:avatar_url]).not_to be_nil
     end
 
     it "has the author's name" do
-      expect(subject.code_events.first[:author][:name]).to eq(MergeRequest.first.author.name)
+      expect(events.first[:author][:name]).to eq(MergeRequest.first.author.name)
     end
   end
 
   describe '#test_events' do
+    let(:stage) { :test }
+
     let(:merge_request) { MergeRequest.first }
     let!(:pipeline) do
       create(:ci_pipeline,
@@ -130,83 +140,85 @@ describe Gitlab::CycleAnalytics::Events do
     end
 
     it 'has the name' do
-      expect(subject.test_events.first[:name]).not_to be_nil
+      expect(events.first[:name]).not_to be_nil
     end
 
     it 'has the ID' do
-      expect(subject.test_events.first[:id]).not_to be_nil
+      expect(events.first[:id]).not_to be_nil
     end
 
     it 'has the URL' do
-      expect(subject.test_events.first[:url]).not_to be_nil
+      expect(events.first[:url]).not_to be_nil
     end
 
     it 'has the branch name' do
-      expect(subject.test_events.first[:branch]).not_to be_nil
+      expect(events.first[:branch]).not_to be_nil
     end
 
     it 'has the branch URL' do
-      expect(subject.test_events.first[:branch][:url]).not_to be_nil
+      expect(events.first[:branch][:url]).not_to be_nil
     end
 
     it 'has the short SHA' do
-      expect(subject.test_events.first[:short_sha]).not_to be_nil
+      expect(events.first[:short_sha]).not_to be_nil
     end
 
     it 'has the commit URL' do
-      expect(subject.test_events.first[:commit_url]).not_to be_nil
+      expect(events.first[:commit_url]).not_to be_nil
     end
 
     it 'has the date' do
-      expect(subject.test_events.first[:date]).not_to be_nil
+      expect(events.first[:date]).not_to be_nil
     end
 
     it 'has the total time' do
-      expect(subject.test_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
   end
 
   describe '#review_events' do
+    let(:stage) { :review }
     let!(:context) { create(:issue, project: project, created_at: 2.days.ago) }
 
     it 'has the total time' do
-      expect(subject.review_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
 
     it 'has a title' do
-      expect(subject.review_events.first[:title]).to eq('Awesome merge_request')
+      expect(events.first[:title]).to eq('Awesome merge_request')
     end
 
     it 'has an iid' do
-      expect(subject.review_events.first[:iid]).to eq(context.iid.to_s)
+      expect(events.first[:iid]).to eq(context.iid.to_s)
     end
 
     it 'has the URL' do
-      expect(subject.review_events.first[:url]).not_to be_nil
+      expect(events.first[:url]).not_to be_nil
     end
 
     it 'has a state' do
-      expect(subject.review_events.first[:state]).not_to be_nil
+      expect(events.first[:state]).not_to be_nil
     end
 
     it 'has a created_at timestamp' do
-      expect(subject.review_events.first[:created_at]).not_to be_nil
+      expect(events.first[:created_at]).not_to be_nil
     end
 
     it "has the author's URL" do
-      expect(subject.review_events.first[:author][:web_url]).not_to be_nil
+      expect(events.first[:author][:web_url]).not_to be_nil
     end
 
     it "has the author's avatar URL" do
-      expect(subject.review_events.first[:author][:avatar_url]).not_to be_nil
+      expect(events.first[:author][:avatar_url]).not_to be_nil
     end
 
     it "has the author's name" do
-      expect(subject.review_events.first[:author][:name]).to eq(MergeRequest.first.author.name)
+      expect(events.first[:author][:name]).to eq(MergeRequest.first.author.name)
     end
   end
 
   describe '#staging_events' do
+    let(:stage) { :staging }
     let(:merge_request) { MergeRequest.first }
     let!(:pipeline) do
       create(:ci_pipeline,
@@ -227,55 +239,56 @@ describe Gitlab::CycleAnalytics::Events do
     end
 
     it 'has the name' do
-      expect(subject.staging_events.first[:name]).not_to be_nil
+      expect(events.first[:name]).not_to be_nil
     end
 
     it 'has the ID' do
-      expect(subject.staging_events.first[:id]).not_to be_nil
+      expect(events.first[:id]).not_to be_nil
     end
 
     it 'has the URL' do
-      expect(subject.staging_events.first[:url]).not_to be_nil
+      expect(events.first[:url]).not_to be_nil
     end
 
     it 'has the branch name' do
-      expect(subject.staging_events.first[:branch]).not_to be_nil
+      expect(events.first[:branch]).not_to be_nil
     end
 
     it 'has the branch URL' do
-      expect(subject.staging_events.first[:branch][:url]).not_to be_nil
+      expect(events.first[:branch][:url]).not_to be_nil
     end
 
     it 'has the short SHA' do
-      expect(subject.staging_events.first[:short_sha]).not_to be_nil
+      expect(events.first[:short_sha]).not_to be_nil
     end
 
     it 'has the commit URL' do
-      expect(subject.staging_events.first[:commit_url]).not_to be_nil
+      expect(events.first[:commit_url]).not_to be_nil
     end
 
     it 'has the date' do
-      expect(subject.staging_events.first[:date]).not_to be_nil
+      expect(events.first[:date]).not_to be_nil
     end
 
     it 'has the total time' do
-      expect(subject.staging_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
 
     it "has the author's URL" do
-      expect(subject.staging_events.first[:author][:web_url]).not_to be_nil
+      expect(events.first[:author][:web_url]).not_to be_nil
     end
 
     it "has the author's avatar URL" do
-      expect(subject.staging_events.first[:author][:avatar_url]).not_to be_nil
+      expect(events.first[:author][:avatar_url]).not_to be_nil
     end
 
     it "has the author's name" do
-      expect(subject.staging_events.first[:author][:name]).to eq(MergeRequest.first.author.name)
+      expect(events.first[:author][:name]).to eq(MergeRequest.first.author.name)
     end
   end
 
   describe '#production_events' do
+    let(:stage) { :production }
     let!(:context) { create(:issue, project: project, created_at: 2.days.ago) }
 
     before do
@@ -284,35 +297,35 @@ describe Gitlab::CycleAnalytics::Events do
     end
 
     it 'has the total time' do
-      expect(subject.production_events.first[:total_time]).not_to be_empty
+      expect(events.first[:total_time]).not_to be_empty
     end
 
     it 'has a title' do
-      expect(subject.production_events.first[:title]).to eq(context.title)
+      expect(events.first[:title]).to eq(context.title)
     end
 
     it 'has the URL' do
-      expect(subject.production_events.first[:url]).not_to be_nil
+      expect(events.first[:url]).not_to be_nil
     end
 
     it 'has an iid' do
-      expect(subject.production_events.first[:iid]).to eq(context.iid.to_s)
+      expect(events.first[:iid]).to eq(context.iid.to_s)
     end
 
     it 'has a created_at timestamp' do
-      expect(subject.production_events.first[:created_at]).to end_with('ago')
+      expect(events.first[:created_at]).to end_with('ago')
     end
 
     it "has the author's URL" do
-      expect(subject.production_events.first[:author][:web_url]).not_to be_nil
+      expect(events.first[:author][:web_url]).not_to be_nil
     end
 
     it "has the author's avatar URL" do
-      expect(subject.production_events.first[:author][:avatar_url]).not_to be_nil
+      expect(events.first[:author][:avatar_url]).not_to be_nil
     end
 
     it "has the author's name" do
-      expect(subject.production_events.first[:author][:name]).to eq(context.author.name)
+      expect(events.first[:author][:name]).to eq(context.author.name)
     end
   end
 

spec/lib/gitlab/cycle_analytics/issue_event_spec.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 require 'lib/gitlab/cycle_analytics/shared_event_spec'
 
 describe Gitlab::CycleAnalytics::IssueEvent do
+  let(:stage_name) { :issue }
+
   it_behaves_like 'default query config' do
     it 'has the default order' do
       expect(event.order).to eq(event.start_time_attrs)

spec/lib/gitlab/cycle_analytics/plan_event_spec.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 require 'lib/gitlab/cycle_analytics/shared_event_spec'
 
 describe Gitlab::CycleAnalytics::PlanEvent do
+  let(:stage_name) { :plan }
+
   it_behaves_like 'default query config' do
     it 'has the default order' do
       expect(event.order).to eq(event.start_time_attrs)

spec/lib/gitlab/cycle_analytics/production_event_spec.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 require 'lib/gitlab/cycle_analytics/shared_event_spec'
 
 describe Gitlab::CycleAnalytics::ProductionEvent do
+  let(:stage_name) { :production }
+
   it_behaves_like 'default query config' do
     it 'has the default order' do
       expect(event.order).to eq(event.start_time_attrs)

spec/lib/gitlab/cycle_analytics/review_event_spec.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 require 'lib/gitlab/cycle_analytics/shared_event_spec'
 
 describe Gitlab::CycleAnalytics::ReviewEvent do
+  let(:stage_name) { :review }
+
   it_behaves_like 'default query config' do
     it 'has the default order' do
       expect(event.order).to eq(event.start_time_attrs)

spec/lib/gitlab/cycle_analytics/shared_event_spec.rb

 require 'spec_helper'
 
 shared_examples 'default query config' do
-  let(:event) { described_class.new(project: double, options: {}) }
+  let(:fetcher) do
+    Gitlab::CycleAnalytics::MetricsFetcher.new(project: create(:empty_project),
+                                               from: 1.day.ago,
+                                               branch: nil)
+  end
+
+  let(:event) { described_class.new(fetcher: fetcher, stage: stage_name, options: {}) }
 
   it 'has the start attributes' do
     expect(event.start_time_attrs).not_to be_nil

spec/lib/gitlab/cycle_analytics/staging_event_spec.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 require 'lib/gitlab/cycle_analytics/shared_event_spec'
 
 describe Gitlab::CycleAnalytics::StagingEvent do
+  let(:stage_name) { :staging }
+
   it_behaves_like 'default query config' do
     it 'does not have the default order' do
       expect(event.order).not_to eq(event.start_time_attrs)

spec/lib/gitlab/cycle_analytics/test_event_spec.rb

@@ -2,6 +2,8 @@ require 'spec_helper'
 require 'lib/gitlab/cycle_analytics/shared_event_spec'
 
 describe Gitlab::CycleAnalytics::TestEvent do
+  let(:stage_name) { :test }
+
   it_behaves_like 'default query config' do
     it 'does not have the default order' do
       expect(event.order).not_to eq(event.start_time_attrs)

spec/models/cycle_analytics/summary_spec.rb

 require 'spec_helper'
 
-describe CycleAnalytics::Summary, models: true do
+describe Gitlab::CycleAnalytics::StageSummary, models: true do
   let(:project) { create(:project) }
   let(:from) { Time.now }
   let(:user) { create(:user, :admin) }

spec/serializers/analytics_summary_serializer_spec.rb

@@ -8,10 +8,10 @@ describe AnalyticsSummarySerializer do
 
   let(:json) { serializer.as_json }
   let(:project) { create(:empty_project) }
-  let(:resource) { Gitlab::CycleAnalytics::Summary::Issue.new(project: double, from: 1.day.ago) }
+  let(:resource) { Gitlab::CycleAnalytics::StageSummary::Issue.new(project: double, from: 1.day.ago) }
 
   before do
-    allow_any_instance_of(Gitlab::CycleAnalytics::Summary::Issue).to receive(:value).and_return(1.12)
+    allow_any_instance_of(Gitlab::CycleAnalytics::StageSummary::Issue).to receive(:value).and_return(1.12)
   end
 
   it 'it generates payload for single object' do