Merge branch 'mo-add-codequality-report-comparison' into 'master'

Add codequality report comparison logic

See merge request gitlab-org/gitlab!48385

app/serializers/codequality_degradation_entity.rb

+# frozen_string_literal: true
+
+class CodequalityDegradationEntity < Grape::Entity
+  expose :description
+  expose :severity
+
+  expose :file_path do |degradation|
+    degradation.dig(:location, :path)
+  end
+
+  expose :line do |degradation|
+    degradation.dig(:location, :lines, :begin) || degradation.dig(:location, :positions, :begin, :line)
+  end
+end

app/serializers/codequality_reports_comparer_entity.rb

+# frozen_string_literal: true
+
+class CodequalityReportsComparerEntity < Grape::Entity
+  expose :status
+
+  expose :new_errors, using: CodequalityDegradationEntity
+  expose :resolved_errors, using: CodequalityDegradationEntity
+  expose :existing_errors, using: CodequalityDegradationEntity
+
+  expose :summary do
+    expose :total_count, as: :total
+    expose :resolved_count, as: :resolved
+    expose :errors_count, as: :errored
+  end
+end

app/serializers/codequality_reports_comparer_serializer.rb

+# frozen_string_literal: true
+
+class CodequalityReportsComparerSerializer < BaseSerializer
+  entity CodequalityReportsComparerEntity
+end

lib/gitlab/ci/reports/codequality_reports_comparer.rb

+# frozen_string_literal: true
+
+module Gitlab
+  module Ci
+    module Reports
+      class CodequalityReportsComparer
+        include Gitlab::Utils::StrongMemoize
+
+        STATUS_SUCCESS = 'success'
+        STATUS_FAILED = 'failed'
+
+        attr_reader :base_report, :head_report
+
+        def initialize(base_report, head_report)
+          @base_report = base_report || CodequalityReports.new
+          @head_report = head_report
+        end
+
+        def status
+          head_report.degradations_count > 0 ? STATUS_FAILED : STATUS_SUCCESS
+        end
+
+        def existing_errors
+          strong_memoize(:existing_errors) do
+            base_report.all_degradations & head_report.all_degradations
+          end
+        end
+
+        def new_errors
+          strong_memoize(:new_errors) do
+            fingerprints = head_report.degradations.keys - base_report.degradations.keys
+            head_report.degradations.fetch_values(*fingerprints)
+          end
+        end
+
+        def resolved_errors
+          strong_memoize(:resolved_errors) do
+            fingerprints = base_report.degradations.keys - head_report.degradations.keys
+            base_report.degradations.fetch_values(*fingerprints)
+          end
+        end
+
+        def errors_count
+          head_report.degradations_count
+        end
+
+        def resolved_count
+          resolved_errors.size
+        end
+
+        def total_count
+          existing_errors.size + new_errors.size
+        end
+      end
+    end
+  end
+end

spec/fixtures/api/schemas/entities/codequality_degradation.json

+{
+  "type": "object",
+  "required": [
+    "description",
+    "severity",
+    "file_path",
+    "line"
+  ],
+  "properties": {
+    "description": {
+      "type": "string"
+    },
+    "severity": {
+      "type": "string"
+    },
+    "file_path": {
+      "type": "string"
+    },
+    "line": {
+      "type": "integer"
+    }
+  },
+  "additionalProperties": false
+}

spec/fixtures/api/schemas/entities/codequality_reports_comparer.json

+{
+  "type": "object",
+  "required": ["status", "summary", "new_errors", "resolved_errors", "existing_errors"],
+  "properties": {
+    "status": {
+      "type": "string"
+    },
+    "summary": {
+      "type": "object",
+      "properties": {
+        "total": {
+          "type": "integer"
+        },
+        "resolved": {
+          "type": "integer"
+        },
+        "errored": {
+          "type": "integer"
+        }
+      },
+      "required": ["total", "resolved", "errored"]
+    },
+    "new_errors": {
+      "type": "array",
+      "items": {
+        "$ref": "codequality_degradation.json"
+      }
+    },
+    "resolved_errors": {
+      "type": "array",
+      "items": {
+        "$ref": "codequality_degradation.json"
+      }
+    },
+    "existing_errors": {
+      "type": "array",
+      "items": {
+        "$ref": "codequality_degradation.json"
+      }
+    }
+  },
+  "additionalProperties": false
+}

spec/lib/gitlab/ci/reports/codequality_reports_comparer_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Gitlab::Ci::Reports::CodequalityReportsComparer do
+  let(:comparer) { described_class.new(base_report, head_report) }
+  let(:base_report) { Gitlab::Ci::Reports::CodequalityReports.new }
+  let(:head_report) { Gitlab::Ci::Reports::CodequalityReports.new }
+  let(:degradation_1) do
+    {
+      "categories": [
+        "Complexity"
+      ],
+      "check_name": "argument_count",
+      "content": {
+        "body": ""
+      },
+      "description": "Method `new_array` has 12 arguments (exceeds 4 allowed). Consider refactoring.",
+      "fingerprint": "15cdb5c53afd42bc22f8ca366a08d547",
+      "location": {
+        "path": "foo.rb",
+        "lines": {
+          "begin": 10,
+          "end": 10
+        }
+      },
+      "other_locations": [],
+      "remediation_points": 900000,
+      "severity": "major",
+      "type": "issue",
+      "engine_name": "structure"
+    }.with_indifferent_access
+  end
+
+  let(:degradation_2) do
+    {
+      "type": "Issue",
+      "check_name": "Rubocop/Metrics/ParameterLists",
+      "description": "Avoid parameter lists longer than 5 parameters. [12/5]",
+      "categories": [
+        "Complexity"
+      ],
+      "remediation_points": 550000,
+      "location": {
+        "path": "foo.rb",
+        "positions": {
+          "begin": {
+            "column": 14,
+            "line": 10
+          },
+          "end": {
+            "column": 39,
+            "line": 10
+          }
+        }
+      },
+      "content": {
+        "body": "This cop checks for methods with too many parameters.\nThe maximum number of parameters is configurable.\nKeyword arguments can optionally be excluded from the total count."
+      },
+      "engine_name": "rubocop",
+      "fingerprint": "ab5f8b935886b942d621399f5a2ca16e",
+      "severity": "minor"
+    }.with_indifferent_access
+  end
+
+  describe '#status' do
+    subject(:report_status) { comparer.status }
+
+    context 'when head report has an error' do
+      before do
+        head_report.add_degradation(degradation_1)
+      end
+
+      it 'returns status failed' do
+        expect(report_status).to eq(described_class::STATUS_FAILED)
+      end
+    end
+
+    context 'when head report does not have errors' do
+      it 'returns status success' do
+        expect(report_status).to eq(described_class::STATUS_SUCCESS)
+      end
+    end
+  end
+
+  describe '#errors_count' do
+    subject(:errors_count) { comparer.errors_count }
+
+    context 'when head report has an error' do
+      before do
+        head_report.add_degradation(degradation_1)
+      end
+
+      it 'returns the number of new errors' do
+        expect(errors_count).to eq(1)
+      end
+    end
+
+    context 'when head report does not have an error' do
+      it 'returns zero' do
+        expect(errors_count).to be_zero
+      end
+    end
+  end
+
+  describe '#resolved_count' do
+    subject(:resolved_count) { comparer.resolved_count }
+
+    context 'when base report has an error and head has a different error' do
+      before do
+        base_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_2)
+      end
+
+      it 'counts the base report error as resolved' do
+        expect(resolved_count).to eq(1)
+      end
+    end
+
+    context 'when base report has errors head has no errors' do
+      before do
+        base_report.add_degradation(degradation_1)
+      end
+
+      it 'counts the base report errors as resolved' do
+        expect(resolved_count).to eq(1)
+      end
+    end
+
+    context 'when base report has errors and head has the same error' do
+      before do
+        base_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_1)
+      end
+
+      it 'returns zero' do
+        expect(resolved_count).to eq(0)
+      end
+    end
+
+    context 'when base report does not have errors and head has errors' do
+      before do
+        head_report.add_degradation(degradation_1)
+      end
+
+      it 'returns zero' do
+        expect(resolved_count).to be_zero
+      end
+    end
+  end
+
+  describe '#total_count' do
+    subject(:total_count) { comparer.total_count }
+
+    context 'when base report has an error' do
+      before do
+        base_report.add_degradation(degradation_1)
+      end
+
+      it 'returns zero' do
+        expect(total_count).to be_zero
+      end
+    end
+
+    context 'when head report has an error' do
+      before do
+        head_report.add_degradation(degradation_1)
+      end
+
+      it 'includes the head report error in the count' do
+        expect(total_count).to eq(1)
+      end
+    end
+
+    context 'when base report has errors and head report has errors' do
+      before do
+        base_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_2)
+      end
+
+      it 'includes errors in the count' do
+        expect(total_count).to eq(1)
+      end
+    end
+
+    context 'when base report has errors and head report has the same error' do
+      before do
+        base_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_2)
+      end
+
+      it 'includes errors in the count' do
+        expect(total_count).to eq(2)
+      end
+    end
+  end
+
+  describe '#existing_errors' do
+    subject(:existing_errors) { comparer.existing_errors }
+
+    context 'when base report has errors and head has the same error' do
+      before do
+        base_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_2)
+      end
+
+      it 'includes the base report errors' do
+        expect(existing_errors).to contain_exactly(degradation_1)
+      end
+    end
+
+    context 'when base report has errors and head has a different error' do
+      before do
+        base_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_2)
+      end
+
+      it 'returns an empty array' do
+        expect(existing_errors).to be_empty
+      end
+    end
+
+    context 'when base report does not have errors and head has errors' do
+      before do
+        head_report.add_degradation(degradation_1)
+      end
+
+      it 'returns an empty array' do
+        expect(existing_errors).to be_empty
+      end
+    end
+  end
+
+  describe '#new_errors' do
+    subject(:new_errors) { comparer.new_errors }
+
+    context 'when base report has errors and head has more errors' do
+      before do
+        base_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_2)
+      end
+
+      it 'includes errors not found in the base report' do
+        expect(new_errors).to eq([degradation_2])
+      end
+    end
+
+    context 'when base report has an error and head has no errors' do
+      before do
+        base_report.add_degradation(degradation_1)
+      end
+
+      it 'returns an empty array' do
+        expect(new_errors).to be_empty
+      end
+    end
+
+    context 'when base report does not have errors and head has errors' do
+      before do
+        head_report.add_degradation(degradation_1)
+      end
+
+      it 'returns the head report error' do
+        expect(new_errors).to eq([degradation_1])
+      end
+    end
+  end
+
+  describe '#resolved_errors' do
+    subject(:resolved_errors) { comparer.resolved_errors }
+
+    context 'when base report errors are still found in the head report' do
+      before do
+        base_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_2)
+      end
+
+      it 'returns an empty array' do
+        expect(resolved_errors).to be_empty
+      end
+    end
+
+    context 'when base report has errors and head has a different error' do
+      before do
+        base_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_2)
+      end
+
+      it 'returns the base report error' do
+        expect(resolved_errors).to eq([degradation_1])
+      end
+    end
+
+    context 'when base report does not have errors and head has errors' do
+      before do
+        head_report.add_degradation(degradation_1)
+      end
+
+      it 'returns an empty array' do
+        expect(resolved_errors).to be_empty
+      end
+    end
+  end
+end

spec/serializers/codequality_degradation_entity_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CodequalityDegradationEntity do
+  let(:entity) { described_class.new(codequality_degradation) }
+
+  describe '#as_json' do
+    subject { entity.as_json }
+
+    context 'when codequality contains an error' do
+      context 'when line is included in location' do
+        let(:codequality_degradation) do
+          {
+            "categories": [
+              "Complexity"
+            ],
+            "check_name": "argument_count",
+            "content": {
+              "body": ""
+            },
+            "description": "Method `new_array` has 12 arguments (exceeds 4 allowed). Consider refactoring.",
+            "fingerprint": "15cdb5c53afd42bc22f8ca366a08d547",
+            "location": {
+              "path": "foo.rb",
+              "lines": {
+                "begin": 10,
+                "end": 10
+              }
+            },
+            "other_locations": [],
+            "remediation_points": 900000,
+            "severity": "major",
+            "type": "issue",
+            "engine_name": "structure"
+          }.with_indifferent_access
+        end
+
+        it 'contains correct codequality degradation details', :aggregate_failures do
+          expect(subject[:description]).to eq("Method `new_array` has 12 arguments (exceeds 4 allowed). Consider refactoring.")
+          expect(subject[:severity]).to eq("major")
+          expect(subject[:file_path]).to eq("foo.rb")
+          expect(subject[:line]).to eq(10)
+        end
+      end
+
+      context 'when line is included in positions' do
+        let(:codequality_degradation) do
+          {
+            "type": "Issue",
+            "check_name": "Rubocop/Metrics/ParameterLists",
+            "description": "Avoid parameter lists longer than 5 parameters. [12/5]",
+            "categories": [
+              "Complexity"
+            ],
+            "remediation_points": 550000,
+            "location": {
+              "path": "foo.rb",
+              "positions": {
+                "begin": {
+                  "column": 24,
+                  "line": 14
+                },
+                "end": {
+                  "column": 49,
+                  "line": 14
+                }
+              }
+            },
+            "content": {
+              "body": "This cop checks for methods with too many parameters.\nThe maximum number of parameters is configurable.\nKeyword arguments can optionally be excluded from the total count."
+            },
+            "engine_name": "rubocop",
+            "fingerprint": "ab5f8b935886b942d621399f5a2ca16e",
+            "severity": "minor"
+          }.with_indifferent_access
+        end
+
+        it 'contains correct codequality degradation details', :aggregate_failures do
+          expect(subject[:description]).to eq("Avoid parameter lists longer than 5 parameters. [12/5]")
+          expect(subject[:severity]).to eq("minor")
+          expect(subject[:file_path]).to eq("foo.rb")
+          expect(subject[:line]).to eq(14)
+        end
+      end
+    end
+  end
+end

spec/serializers/codequality_reports_comparer_entity_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CodequalityReportsComparerEntity do
+  let(:entity) { described_class.new(comparer) }
+  let(:comparer) { Gitlab::Ci::Reports::CodequalityReportsComparer.new(base_report, head_report) }
+  let(:base_report) { Gitlab::Ci::Reports::CodequalityReports.new }
+  let(:head_report) { Gitlab::Ci::Reports::CodequalityReports.new }
+  let(:degradation_1) do
+    {
+      "categories": [
+        "Complexity"
+      ],
+      "check_name": "argument_count",
+      "content": {
+        "body": ""
+      },
+      "description": "Method `new_array` has 12 arguments (exceeds 4 allowed). Consider refactoring.",
+      "fingerprint": "15cdb5c53afd42bc22f8ca366a08d547",
+      "location": {
+        "path": "foo.rb",
+        "lines": {
+          "begin": 10,
+          "end": 10
+        }
+      },
+      "other_locations": [],
+      "remediation_points": 900000,
+      "severity": "major",
+      "type": "issue",
+      "engine_name": "structure"
+    }.with_indifferent_access
+  end
+
+  let(:degradation_2) do
+    {
+      "type": "Issue",
+      "check_name": "Rubocop/Metrics/ParameterLists",
+      "description": "Avoid parameter lists longer than 5 parameters. [12/5]",
+      "categories": [
+        "Complexity"
+      ],
+      "remediation_points": 550000,
+      "location": {
+        "path": "foo.rb",
+        "positions": {
+          "begin": {
+            "column": 14,
+            "line": 10
+          },
+          "end": {
+            "column": 39,
+            "line": 10
+          }
+        }
+      },
+      "content": {
+        "body": "This cop checks for methods with too many parameters.\nThe maximum number of parameters is configurable.\nKeyword arguments can optionally be excluded from the total count."
+      },
+      "engine_name": "rubocop",
+      "fingerprint": "ab5f8b935886b942d621399f5a2ca16e",
+      "severity": "minor"
+    }.with_indifferent_access
+  end
+
+  describe '#as_json' do
+    subject { entity.as_json }
+
+    context 'when base and head report have errors' do
+      before do
+        base_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_2)
+      end
+
+      it 'contains correct compared codequality report details', :aggregate_failures do
+        expect(subject[:status]).to eq(Gitlab::Ci::Reports::CodequalityReportsComparer::STATUS_FAILED)
+        expect(subject[:resolved_errors].first).to include(:description, :severity, :file_path, :line)
+        expect(subject[:new_errors].first).to include(:description, :severity, :file_path, :line)
+        expect(subject[:existing_errors]).to be_empty
+        expect(subject[:summary]).to include(total: 1, resolved: 1, errored: 1)
+      end
+    end
+  end
+end

spec/serializers/codequality_reports_comparer_serializer_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe CodequalityReportsComparerSerializer do
+  let(:project) { double(:project) }
+  let(:serializer) { described_class.new(project: project).represent(comparer) }
+  let(:comparer) { Gitlab::Ci::Reports::CodequalityReportsComparer.new(base_report, head_report) }
+  let(:base_report) { Gitlab::Ci::Reports::CodequalityReports.new }
+  let(:head_report) { Gitlab::Ci::Reports::CodequalityReports.new }
+  let(:degradation_1) do
+    {
+      "categories": [
+        "Complexity"
+      ],
+      "check_name": "argument_count",
+      "content": {
+        "body": ""
+      },
+      "description": "Method `new_array` has 12 arguments (exceeds 4 allowed). Consider refactoring.",
+      "fingerprint": "15cdb5c53afd42bc22f8ca366a08d547",
+      "location": {
+        "path": "foo.rb",
+        "lines": {
+          "begin": 10,
+          "end": 10
+        }
+      },
+      "other_locations": [],
+      "remediation_points": 900000,
+      "severity": "major",
+      "type": "issue",
+      "engine_name": "structure"
+    }.with_indifferent_access
+  end
+
+  let(:degradation_2) do
+    {
+      "type": "Issue",
+      "check_name": "Rubocop/Metrics/ParameterLists",
+      "description": "Avoid parameter lists longer than 5 parameters. [12/5]",
+      "categories": [
+        "Complexity"
+      ],
+      "remediation_points": 550000,
+      "location": {
+        "path": "foo.rb",
+        "positions": {
+          "begin": {
+            "column": 14,
+            "line": 10
+          },
+          "end": {
+            "column": 39,
+            "line": 10
+          }
+        }
+      },
+      "content": {
+        "body": "This cop checks for methods with too many parameters.\nThe maximum number of parameters is configurable.\nKeyword arguments can optionally be excluded from the total count."
+      },
+      "engine_name": "rubocop",
+      "fingerprint": "ab5f8b935886b942d621399f5a2ca16e",
+      "severity": "minor"
+    }.with_indifferent_access
+  end
+
+  describe '#to_json' do
+    subject { serializer.as_json }
+
+    context 'when base report has error and head has a different error' do
+      before do
+        base_report.add_degradation(degradation_1)
+        head_report.add_degradation(degradation_2)
+      end
+
+      it 'matches the schema' do
+        expect(subject).to match_schema('entities/codequality_reports_comparer')
+      end
+    end
+
+    context 'when base report has no error and head has errors' do
+      before do
+        head_report.add_degradation(degradation_1)
+      end
+
+      it 'matches the schema' do
+        expect(subject).to match_schema('entities/codequality_reports_comparer')
+      end
+    end
+  end
+end