gitlab_quality-test_tooling 0.1.0 → 0.2.1

data/lib/gitlab_quality/test_tooling/report/prepare_stage_reports.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      class PrepareStageReports
+        EXTRACT_STAGE_FROM_TEST_FILE_REGEX = %r{(?:api|browser_ui)/(?:[0-9]+_)?(?<stage>[_\w]+)/}i
+
+        def initialize(junit_files:)
+          @junit_files = junit_files
+        end
+
+        def invoke!
+          collate_test_cases.each do |stage, tests|
+            filename = "#{stage}.xml"
+
+            File.write(filename, junit_report(tests).to_s)
+
+            puts "Saved #{filename}"
+          end
+        end
+
+        private
+
+        attr_reader :junit_files
+
+        # Collect the test cases from the original reports and group them by Stage
+        def collate_test_cases
+          Dir.glob(junit_files)
+            .each_with_object(Hash.new { |h, k| h[k] = [] }) do |junit_file, test_cases|
+            report = Nokogiri::XML(File.open(junit_file))
+            report.xpath('//testcase').each do |test_case|
+              # The test file paths could start with any of
+              #  /qa/specs/features/api/<stage>
+              #  /qa/specs/features/browser_ui/<stage>
+              #  /qa/specs/features/ee/api/<stage>
+              #  /qa/specs/features/ee/browser_ui/<stage>
+              # For now we assume the Stage is whatever follows api/ or browser_ui/
+              test_file_match = test_case['file'].match(EXTRACT_STAGE_FROM_TEST_FILE_REGEX)
+              next unless test_file_match
+
+              stage = test_file_match[:stage]
+              test_cases[stage] << test_case
+            end
+          end
+        end
+
+        def junit_report(test_cases)
+          Nokogiri::XML::Document.new.tap do |report|
+            test_suite_node = report.create_element('testsuite', name: 'rspec', **collect_stats(test_cases))
+            report.root = test_suite_node
+
+            test_cases.each do |test_case|
+              test_suite_node.add_child(test_case)
+            end
+          end
+        end
+
+        def collect_stats(test_cases)
+          stats = {
+            tests: test_cases.size,
+            failures: 0,
+            errors: 0,
+            skipped: 0
+          }
+
+          test_cases.each_with_object(stats) do |test_case, memo|
+            memo[:failures] += 1 unless test_case.search('failure').empty?
+            memo[:errors] += 1 unless test_case.search('error').empty?
+            memo[:skipped] += 1 unless test_case.search('skipped').empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/relate_failure_issue.rb

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'active_support/core_ext/enumerable'
+require 'rubygems/text'
+require 'active_support/core_ext/integer/time'
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      # Uses the API to create or update GitLab issues with the results of tests from RSpec report files.
+      # - Uses the API to create or update GitLab issues with the results of tests from RSpec report files.
+      # - Takes the JSON test run reports, e.g. `$CI_PROJECT_DIR/gitlab-qa-run-*/**/rspec-*.json`
+      # - Takes a project where failure issues should be created
+      # - Find issue by title (with test description or test file), then further filter by stack trace, then pick the better-matching one
+      # - Post a note to the latest failed job, e.g. https://gitlab.com/gitlab-org/gitlab/-/issues/408333#note_1361882769
+      # - Update labels
+      class RelateFailureIssue < ReportAsIssue
+        include Concerns::FindSetDri
+
+        DEFAULT_MAX_DIFF_RATIO_FOR_DETECTION = 0.15
+        SPAM_THRESHOLD_FOR_FAILURE_ISSUES = 3
+        FAILURE_STACKTRACE_REGEX = %r{(?:(?:.*Failure/Error:(?<stacktrace>.+))|(?<stacktrace>.+))}m
+        ISSUE_STACKTRACE_REGEX = /### Stack trace\s*(```)#{FAILURE_STACKTRACE_REGEX}(```)/m
+        FAILED_JOB_DESCRIPTION_REGEX = %r{First happened in https?://\S+\.}m
+        FAILED_JOB_NOTE_REGEX = %r{Failed most recently in \D+ pipeline: https?://\S+}
+        NEW_ISSUE_LABELS = Set.new(%w[QA Quality test failure::new priority::2]).freeze
+        IGNORE_EXCEPTIONS = ['Net::ReadTimeout'].freeze
+        SCREENSHOT_IGNORED_ERRORS = ['500 Internal Server Error', 'fabricate_via_api!', 'Error Code 500'].freeze
+
+        MultipleIssuesFound = Class.new(StandardError)
+
+        def initialize(max_diff_ratio: DEFAULT_MAX_DIFF_RATIO_FOR_DETECTION, system_logs: [], **kwargs)
+          super
+          @max_diff_ratio = max_diff_ratio.to_f
+          @system_logs = Dir.glob(system_logs)
+          @issue_type = 'issue'
+          @commented_issue_list = Set.new
+        end
+
+        private
+
+        attr_reader :max_diff_ratio, :system_logs
+
+        def run!
+          puts "Reporting test failures in `#{files.join(',')}` as issues in project `#{project}` via the API at `#{Runtime::Env.gitlab_api_base}`."
+
+          TestResults::Builder.new(files).test_results_per_file do |test_results|
+            puts "=> Reporting tests in #{test_results.path}"
+
+            test_results.each do |test|
+              relate_failure_to_issue(test) if should_report?(test)
+            end
+
+            test_results.write
+          end
+        end
+
+        def relate_failure_to_issue(test)
+          puts "  => Searching issues for test '#{test.name}'..."
+
+          begin
+            issue = test.quarantine? ? find_and_link_issue(test) : find_and_link_issue(test) || create_issue(test)
+            return unless issue
+
+            update_labels(issue, test)
+          rescue MultipleIssuesFound => e
+            warn(e.message)
+          end
+        end
+
+        def find_and_link_issue(test)
+          issue, diff_ratio = find_failure_issue(test)
+          issue_already_commented = issue ? @commented_issue_list.include?(issue.web_url) : nil
+
+          if issue && !issue_already_commented
+            puts "  => Found issue #{issue.web_url} for test '#{test.name}' with a diff ratio of #{(diff_ratio * 100).round(2)}%."
+            post_or_update_failed_job_note(issue, test)
+            @commented_issue_list.add(issue.web_url)
+          else
+            puts " => Failure already commented on issue." if issue_already_commented
+
+            return false
+          end
+
+          issue
+        end
+
+        def create_issue(test)
+          similar_issues = pipeline_issues_with_similar_stacktrace(test)
+
+          if similar_issues.size >= SPAM_THRESHOLD_FOR_FAILURE_ISSUES
+            puts " => Similar failure issues have already been opened for same pipeline environment"
+            puts " => Will not create new issue for this failing spec"
+            similar_issues.each do |similar_issue|
+              puts "Please check issue: #{similar_issue.web_url}"
+              gitlab.create_issue_note(iid: similar_issue.iid,
+                note: "This failed job is most likely related: #{test.ci_job_url}")
+            end
+            return
+          end
+
+          issue = super
+          puts "for test '#{test.name}'."
+
+          post_or_update_failed_job_note(issue, test)
+
+          assign_dri(issue, test)
+
+          issue
+        end
+
+        def pipeline_issues_with_similar_stacktrace(test)
+          gitlab.find_issues(options: { state: 'opened', labels: 'QA,failure::new',
+                                        created_after: past_timestamp(2) }).select do |issue|
+            job_url_from_issue = failed_issue_job_url(issue)
+            next unless pipeline == pipeline_env_from_job_url(job_url_from_issue)
+
+            stack_trace_from_issue = cleaned_stack_trace_from_issue(issue)
+            stack_trace_from_test = cleaned_stacktrace_from_test(test)
+            diff_ratio = compare_stack_traces(stack_trace_from_test, stack_trace_from_issue)
+            diff_ratio < max_diff_ratio
+          end
+        end
+
+        def failed_issue_job_url(issue)
+          existing_note = existing_failure_note(issue)
+          if existing_note
+            job_url_string = existing_note.body
+            matched = job_url_string.match(FAILED_JOB_NOTE_REGEX)
+          else
+            job_url_string = issue.description
+            matched = job_url_string.match(FAILED_JOB_DESCRIPTION_REGEX)
+          end
+
+          return unless matched
+
+          job_url = matched[0].chop.split.last
+          puts "=> Found failed job url in the issue: #{job_url}"
+          job_url
+        end
+
+        def pipeline_env_from_job_url(job_url)
+          return if job_url.nil?
+
+          if job_url.include?('/quality/')
+            job_url.partition('/quality/').last.partition('/').first
+          else
+            'master'
+          end
+        end
+
+        def past_timestamp(hours_ago)
+          timestamp = Time.now - (hours_ago * 60 * 60)
+          timestamp.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+        end
+
+        def failure_issues(test)
+          gitlab.find_issues(options: { state: 'opened', labels: 'QA' }).select do |issue|
+            issue_title = issue.title.strip
+            issue_title.include?(test.name) || issue_title.include?(partial_file_path(test.file))
+          end
+        end
+
+        def full_stacktrace(test)
+          if test.failures.first['message_lines'].empty? || test.failures.first['message_lines'].instance_of?(String)
+            test.failures.first['message']
+          else
+            test.failures.first['message_lines'].join("\n")
+          end
+        end
+
+        def cleaned_stack_trace_from_issue(issue)
+          relevant_issue_stacktrace = find_issue_stacktrace(issue)
+          return unless relevant_issue_stacktrace
+
+          remove_unique_resource_names(relevant_issue_stacktrace)
+        end
+
+        def cleaned_stacktrace_from_test(test)
+          first_test_failure_stacktrace = sanitize_stacktrace(full_stacktrace(test),
+            FAILURE_STACKTRACE_REGEX) || full_stacktrace(test)
+          remove_unique_resource_names(first_test_failure_stacktrace)
+        end
+
+        def compare_stack_traces(stack_trace_first, stack_trace_second)
+          calculate_diff_ratio(stack_trace_first, stack_trace_second)
+        end
+
+        def calculate_diff_ratio(stack_trace_first, stack_trace_second)
+          ld = Class.new.extend(Gem::Text).method(:levenshtein_distance)
+          distance = ld.call(stack_trace_first, stack_trace_second)
+          distance.zero? ? 0.0 : (distance.to_f / stack_trace_first.size).round(3)
+        end
+
+        def find_relevant_failure_issues(test) # rubocop:disable Metrics/AbcSize
+          clean_first_test_failure_stacktrace = cleaned_stacktrace_from_test(test)
+          # Search with the `search` param returns 500 errors, so we filter by ~QA and then filter further in Ruby
+          failure_issues(test).each_with_object({}) do |issue, memo|
+            clean_relevant_issue_stacktrace = cleaned_stack_trace_from_issue(issue)
+            next if clean_relevant_issue_stacktrace.nil?
+
+            diff_ratio = compare_stack_traces(clean_first_test_failure_stacktrace, clean_relevant_issue_stacktrace)
+            if diff_ratio <= max_diff_ratio
+              puts "  => [DEBUG] Issue #{issue.web_url} has an acceptable diff ratio of #{(diff_ratio * 100).round(2)}%."
+              # The `Gitlab::ObjectifiedHash` class overrides `#hash` which is used by `Hash#[]=` to compute the hash key.
+              # This leads to a `TypeError Exception: no implicit conversion of Hash into Integer` error, so we convert the object to a hash before using it as a Hash key.
+              # See:
+              # - https://gitlab.com/gitlab-org/gitlab-qa/-/merge_requests/587#note_453336995
+              # - https://github.com/NARKOZ/gitlab/commit/cbdbd1e32623f018a8fae39932a8e3bc4d929abb?_pjax=%23js-repo-pjax-container#r44484494
+              memo[issue.to_h] = diff_ratio
+            else
+              puts "  => [DEBUG] Found issue #{issue.web_url} but stacktraces are too different (#{(diff_ratio * 100).round(2)}%).\n"
+              puts "  => [DEBUG] Issue stacktrace:\n----------------\n#{clean_relevant_issue_stacktrace}\n----------------\n"
+              puts "  => [DEBUG] Failure stacktrace:\n----------------\n#{clean_first_test_failure_stacktrace}\n----------------\n"
+            end
+          end
+        end
+
+        def find_issue_stacktrace(issue)
+          issue_stacktrace = sanitize_stacktrace(issue.description, ISSUE_STACKTRACE_REGEX)
+          return issue_stacktrace if issue_stacktrace
+
+          puts "  => [DEBUG] Stacktrace couldn't be found for #{issue.web_url}!"
+        end
+
+        def sanitize_stacktrace(stacktrace, regex)
+          stacktrace_match = stacktrace.match(regex)
+
+          if stacktrace_match
+            stacktrace_match[:stacktrace].split('First happened in')[0].gsub(/^\s*#.*$/, '').gsub(/^[[:space:]]+/,
+              '').strip
+          else
+            puts "  => [DEBUG] Stacktrace doesn't match the expected regex (#{regex}):\n----------------\n#{stacktrace}\n----------------\n"
+          end
+        end
+
+        def remove_unique_resource_names(stacktrace)
+          stacktrace.gsub(/qa-(test|user)-[a-z0-9-]+/, '<unique-test-resource>').gsub(
+            /(?:-|_)(?:\d+[a-z]|[a-z]+\d)[a-z\d]{4,}/, '<unique-hash>')
+        end
+
+        def find_failure_issue(test)
+          relevant_issues = find_relevant_failure_issues(test)
+
+          return nil if relevant_issues.empty?
+
+          best_matching_issue, smaller_diff_ratio = relevant_issues.min_by { |_, diff_ratio| diff_ratio }
+
+          raise(MultipleIssuesFound, %(Too many issues found for test '#{test.name}' (`#{test.file}`)!)) unless relevant_issues.values.count(smaller_diff_ratio) == 1
+
+          # Re-instantiate a `Gitlab::ObjectifiedHash` object after having converted it to a hash in #find_relevant_failure_issues above.
+          best_matching_issue = Gitlab::ObjectifiedHash.new(best_matching_issue)
+
+          test.failure_issue ||= best_matching_issue.web_url
+
+          [best_matching_issue, smaller_diff_ratio]
+        end
+
+        def new_issue_description(test)
+          super + [
+            "\n### Stack trace",
+            "```\n#{full_stacktrace(test)}\n```",
+            "First happened in #{test.ci_job_url}.",
+            "Related test case: #{test.testcase}.",
+            screenshot_section(test),
+            system_log_errors_section(test)
+          ].compact.join("\n\n")
+        end
+
+        def system_log_errors_section(test)
+          correlation_id = test.failures.first['correlation_id']
+          section = ''
+
+          if system_logs.any? && !correlation_id.nil?
+            section = SystemLogs::SystemLogsFormatter.new(
+              system_logs,
+              correlation_id
+            ).system_logs_summary_markdown
+          end
+
+          puts "  => No system logs or correlation id provided, skipping this section in issue description" if section.empty?
+
+          section
+        end
+
+        def new_issue_labels(test)
+          up_to_date_labels(test: test, new_labels: NEW_ISSUE_LABELS)
+        end
+
+        def up_to_date_labels(test:, issue: nil, new_labels: Set.new)
+          super << pipeline_name_label
+        end
+
+        def post_or_update_failed_job_note(issue, test)
+          current_note = "Failed most recently in #{pipeline} pipeline: #{test.ci_job_url}"
+          existing_note = existing_failure_note(issue)
+
+          if existing_note
+            gitlab.edit_issue_note(issue_iid: issue.iid, note_id: existing_note.id, note: current_note)
+          else
+            gitlab.create_issue_note(iid: issue.iid, note: current_note)
+          end
+
+          puts "  => Linked #{test.ci_job_url} to #{issue.web_url}."
+        end
+
+        def new_issue_title(test)
+          "Failure in #{super}"
+        end
+
+        def existing_failure_note(issue)
+          gitlab.find_issue_notes(iid: issue.iid)&.find do |note|
+            note.body.include?('Failed most recently in')
+          end
+        end
+
+        def screenshot_section(test)
+          return unless test.screenshot?
+
+          failure = full_stacktrace(test)
+          return if SCREENSHOT_IGNORED_ERRORS.any? { |e| failure.include?(e) }
+
+          relative_url = gitlab.upload_file(file_fullpath: test.failure_screenshot)
+          return unless relative_url
+
+          "### Screenshot: #{relative_url.markdown}"
+        end
+
+        def assign_dri(issue, test)
+          if test.product_group?
+            dri = set_dri_via_group(test.product_group, test)
+            dri_id = gitlab.find_user_id(username: dri)
+            gitlab.edit_issue(iid: issue.iid, options: { assignee_id: dri_id, due_date: Date.today + 1.month })
+            puts "  => Assigning #{dri} as DRI for the issue."
+          else
+            puts "  => No product group metadata found for test '#{test.name}'"
+          end
+        end
+
+        # Checks if a test failure should be reported.
+        #
+        # @return [TrueClass|FalseClass] false if the test was skipped or failed because of a transient error that can be ignored.
+        # Otherwise returns true.
+        def should_report?(test)
+          return false if test.failures.empty?
+
+          if test.report.key?('exceptions')
+            reason = ignore_failure_reason(test.report['exceptions'])
+
+            if reason
+              puts "Failure reporting skipped because #{reason}"
+
+              return false
+            end
+          end
+
+          true
+        end
+
+        # Determine any reason to ignore a failure.
+        #
+        # @param [Array<Hash>] exceptions the exceptions associated with the failure.
+        # @return [String] the reason to ignore the exceptions, or `nil` if any exceptions should not be ignored.
+        def ignore_failure_reason(exceptions)
+          exception_classes = exceptions
+            .filter_map { |exception| exception['class'] if IGNORE_EXCEPTIONS.include?(exception['class']) }
+            .compact
+          return if exception_classes.empty? || exception_classes.size < exceptions.size
+
+          msg = exception_classes.many? ? 'the errors were' : 'the error was'
+          "#{msg} #{exception_classes.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/report_as_issue.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      class ReportAsIssue
+        include Concerns::Utils
+
+        def initialize(token:, input_files:, project: nil, dry_run: false, **_kwargs)
+          @project = project
+          @gitlab = (dry_run ? GitlabIssueDryClient : GitlabIssueClient).new(token: token, project: project)
+          @files = Array(input_files)
+        end
+
+        def invoke!
+          validate_input!
+
+          run!
+        end
+
+        private
+
+        attr_reader :gitlab, :files, :project, :issue_type
+
+        def run!
+          raise NotImplementedError
+        end
+
+        def failed_test_hash(test)
+          OpenSSL::Digest::SHA256.hexdigest(test.file + test.name)
+        end
+
+        def new_issue_description(test)
+          <<~DESCRIPTION
+          ### Test metadata (don't modify)
+
+          | Field | Value |
+          | ------ | ------ |
+          | File | `#{test.file}` |
+          | Description | `#{test.name}` |
+          | Hash | `#{failed_test_hash(test)}` |
+          DESCRIPTION
+        end
+
+        def new_issue_labels(_test)
+          []
+        end
+
+        def validate_input!
+          assert_project!
+          assert_input_files!(files)
+          gitlab.assert_user_permission!
+        end
+
+        def assert_project!
+          return if project
+
+          abort "Please provide a valid project ID or path with the `-p/--project` option!"
+        end
+
+        def assert_input_files!(files)
+          return if Dir.glob(files).any?
+
+          abort "Please provide valid JUnit report files. No files were found matching `#{files.join(',')}`"
+        end
+
+        def create_issue(test)
+          issue = gitlab.create_issue(
+            title: title_from_test(test),
+            description: new_issue_description(test),
+            labels: new_issue_labels(test).to_a,
+            issue_type: issue_type
+          )
+
+          new_link = issue_type == 'test_case' ? issue.web_url.sub('/issues/', '/quality/test_cases/') : issue.web_url
+
+          puts "Created new #{issue_type}: #{new_link}"
+
+          issue
+        end
+
+        def issue_labels(issue)
+          issue&.labels&.to_set || Set.new
+        end
+
+        def update_labels(issue, test, new_labels = Set.new)
+          labels = up_to_date_labels(test: test, issue: issue, new_labels: new_labels)
+
+          return if issue_labels(issue) == labels
+
+          gitlab.edit_issue(iid: issue.iid, options: { labels: labels.to_a })
+        end
+
+        def up_to_date_labels(test:, issue: nil, new_labels: Set.new)
+          labels = issue_labels(issue)
+          labels |= new_labels
+          ee_test?(test) ? labels << 'Enterprise Edition' : labels.delete('Enterprise Edition')
+
+          if test.quarantine?
+            labels << 'quarantine'
+            labels << "quarantine::#{test.quarantine_type}"
+          else
+            labels.delete_if { |label| label.include?('quarantine') }
+          end
+
+          labels
+        end
+
+        def pipeline_name_label
+          case pipeline
+          when 'production'
+            'found:gitlab.com'
+          when 'canary', 'staging'
+            "found:#{pipeline}.gitlab.com"
+          when 'staging-canary'
+            "found:canary.staging.gitlab.com"
+          when 'preprod'
+            'found:pre.gitlab.com'
+          when 'nightly', Runtime::Env.default_branch, 'staging-ref', 'release'
+            "found:#{pipeline}"
+          else
+            raise "No `found:*` label for the `#{pipeline}` pipeline!"
+          end
+        end
+
+        def ee_test?(test)
+          test.file =~ %r{features/ee/(api|browser_ui)}
+        end
+      end
+    end
+  end
+end

data/lib/gitlab_quality/test_tooling/report/report_results.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module GitlabQuality
+  module TestTooling
+    module Report
+      # Uses the API to:
+      # - create or update test cases
+      # - create or update issues
+      # based on the results of tests from RSpec run result files.
+      class ReportResults < ReportAsIssue
+        attr_accessor :testcase_project_reporter, :results_issue_project_reporter, :files, :test_case_project,
+          :results_issue_project, :gitlab
+
+        def initialize(
+          token:, input_files:, test_case_project: nil, results_issue_project: nil, dry_run: false,
+          **kwargs)
+          @testcase_project_reporter = GitlabQuality::TestTooling::Report::ResultsInTestCases.new(
+            token: token, input_files: input_files, project: test_case_project, dry_run: dry_run, **kwargs)
+          @results_issue_project_reporter = GitlabQuality::TestTooling::Report::ResultsInIssues.new(
+            token: token, input_files: input_files, project: results_issue_project, dry_run: dry_run, **kwargs)
+          @test_case_project = test_case_project
+          @results_issue_project = results_issue_project
+          @files = Array(input_files)
+          @gitlab = testcase_project_reporter.gitlab
+        end
+
+        def invoke!
+          validate_input!
+
+          run!
+        end
+
+        def validate_input!
+          assert_input_files!(files)
+          gitlab.assert_user_permission!
+        end
+
+        def assert_input_files!(files)
+          return if Dir.glob(files).any?
+
+          abort "Please provide valid JUnit report files. No files were found matching `#{files.join(',')}`"
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def run!
+          puts "Reporting test results in `#{files.join(',')}` as test cases in project `#{test_case_project}` " \
+               "and issues in project `#{results_issue_project}` via the API at `#{Runtime::Env.gitlab_api_base}`."
+
+          TestResults::Builder.new(files).test_results_per_file do |test_results|
+            puts "Reporting tests in #{test_results.path}"
+
+            test_results.each do |test|
+              next if test.file.include?('/features/sanity/') || test.skipped
+
+              puts "Reporting test: #{test.file} | #{test.name}\n"
+
+              report_test(test)
+            end
+
+            test_results.write
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def report_test(test)
+          testcase = testcase_project_reporter.find_or_create_testcase(test)
+          # The API returns the test case with an issue URL since it is technically a type of issue.
+          # This updates the URL to a valid test case link.
+          test.testcase = testcase.web_url.sub('/issues/', '/quality/test_cases/')
+
+          issue, is_new = results_issue_project_reporter.get_related_issue(testcase, test)
+
+          testcase_project_reporter.add_issue_link_to_testcase(testcase, issue, test) if is_new
+
+          testcase_project_reporter.update_testcase(testcase, test)
+          results_issue_project_reporter.update_issue(issue, test)
+        end
+      end
+    end
+  end
+end