supercov-engine 0.0.55

Rust instrumentation, evidence, attribution, and query engine for Supercov
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

# frozen_string_literal: true

# Supercov test-unit adapter: exact test and setup/test/teardown identity plus
# test-unit's own outcome (pass, failure, error, omission, pending).

module Supercov
  module TestUnitAdapter
    RUNNER = "test-unit"

    module TestCaseHooks
      def run(*args, &block)
        Supercov::TestUnitAdapter.start(self)
        super
      ensure
        Supercov::TestUnitAdapter.finish(self)
      end

      def run_setup(&block)
        Supercov::TestUnitAdapter.enter(self, "setup")
        super
      end

      def run_test
        Supercov::TestUnitAdapter.enter(self, "call")
        super
      end

      def run_cleanup
        Supercov::TestUnitAdapter.enter(self, "teardown")
        super
      end

      def run_teardown
        Supercov::TestUnitAdapter.enter(self, "teardown")
        super
      end
    end

    module ResultHooks
      def add_failure(*args)
        Supercov::TestUnitAdapter.note("failed")
        super
      end

      def add_error(*args)
        Supercov::TestUnitAdapter.note("failed")
        super
      end

      def add_omission(*args)
        Supercov::TestUnitAdapter.note("skipped")
        super
      end

      def add_pending(*args)
        Supercov::TestUnitAdapter.note("skipped")
        super
      end
    end

    @runtime = nil
    @state = {}

    def self.install(runtime)
      return if @runtime

      # test-unit loads TestResult from its runner mediator, after TestCase
      # has finished defining. Installing at the class end without it left
      # the result hooks off, so no failure was ever noted, and declared a
      # blocking limitation on every run.
      require "test/unit/testresult"
      ::Test::Unit::TestResult.prepend(ResultHooks)
      ::Test::Unit::TestCase.prepend(TestCaseHooks)
      @runtime = runtime
      runtime.adapter_active = true
    end

    def self.identity(test)
      { worker: @runtime.worker, test: "#{test.class.name}##{test.method_name}", retry: 0, phase: nil }
    end

    # Test::Unit names a class and method, not a path.
    def self.source_file(test)
      test.method(test.method_name).source_location&.first
    rescue NameError
      nil
    end

    def self.start(test)
      @state[Thread.current] = { test: test, phase: nil, phases: {} }
    end

    def self.enter(test, phase)
      state = @state[Thread.current] || start(test)
      return if state[:phase] == phase

      state[:phase] = phase
      state[:phases][phase] ||= "passed"
      identity = identity(test)
      identity[:phase] = phase
      @runtime.switch(identity)
    end

    def self.note(status)
      state = @state[Thread.current]
      return unless state && state[:phase]

      current = state[:phases][state[:phase]]
      state[:phases][state[:phase]] = status unless current == "failed"
    end

    def self.finish(test)
      state = @state.delete(Thread.current)
      return unless state

      identity = identity(test)
      %w[setup call teardown].each do |phase|
        status = state[:phases][phase]
        next if status.nil?

        @runtime.outcome(identity[:worker], identity[:test], 0, phase, status, false, RUNNER, source_file(test))
      end
      @runtime.switch(nil)
    end
  end
end