test_bench-fixture 1.0.0.0 → 1.2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11a8f07325bd4895d293ada5d0562bfe183c8913ff1f1ed2fb85bf770f37a34f
-  data.tar.gz: 3f547833da8e092eeef33a7605621bdd91ac7af38384097dabaacc6eacd493cf
+  metadata.gz: 2c2788177e5994201a774ce4374a65458fe9e6e5c5d2d2066000c5034f56b087
+  data.tar.gz: 53b44687d4060b69a9b3a4504a6b1c79f954179d29560df78dde4916b73ae4c8
 SHA512:
-  metadata.gz: 897778edd91e443502415d4b638517a77835afa40ab53709affab0efd5418b6bb3ce61f2e78bb51782e288bc99c7cd73e98bde4deb7191121e46872d2bb02c48
-  data.tar.gz: a2041b6063d7cfb1979e49ce84248dc32229bef552448332774e2dd7c450e255ab17be19e0f2ede7f904647537add7e60f8adc0de7f91142499663b1b5141fc4
+  metadata.gz: d44875275551502895a4ffa113712e477bdfe7e4e2348f1f28619a7112b7389d8f3b2d8d908aa1ae6af54d67c564a5221b7c880d4d9122b9e9f6d944ac83de5b
+  data.tar.gz: 1250a8026381d3c393f407e2799cc33fcc79b523fa070ffe54ee88661296a98150dc98a4a6ff9f1e74000788cd71ccf922763b9a80c6876a7159924973b775ef

data/lib/test_bench/fixture.rb

@@ -6,13 +6,14 @@ require 'test_bench/fixture/assertion_failure'
 require 'test_bench/fixture/output'
 require 'test_bench/fixture/output/null'
 require 'test_bench/fixture/output/log'
+require 'test_bench/fixture/output/capture'
 require 'test_bench/fixture/output/substitute'
+require 'test_bench/fixture/output/substitute/scope'
 require 'test_bench/fixture/output/multiple'
 
 require 'test_bench/fixture/error_policy'
 
 require 'test_bench/fixture/session'
 require 'test_bench/fixture/session/substitute'
-require 'test_bench/fixture/session/substitute/match_tests'
 
 require 'test_bench/fixture/fixture'

data/lib/test_bench/fixture/controls.rb

@@ -8,3 +8,4 @@ require 'test_bench/fixture/controls/result'
 require 'test_bench/fixture/controls/test_file'
 
 require 'test_bench/fixture/controls/output'
+require 'test_bench/fixture/controls/output/log'

data/lib/test_bench/fixture/controls/output.rb

@@ -34,27 +34,27 @@ module TestBench
             caller_location = Controls::CallerLocation.example
             error = Controls::Error.example
             comment_text = 'Some comment'
+            detail_text = 'Some detail'
             test_title = 'Some test'
             context_title = 'Some Context'
 
             {
               :start => [],
-              :finish => [result],
               :enter_file => [path],
               :exit_file => [path, result],
               :start_fixture => [fixture],
               :finish_fixture => [fixture, result],
               :assert => [result, caller_location],
-              :enter_assert_block => [caller_location],
-              :exit_assert_block => [caller_location, result],
               :comment => [comment_text],
+              :detail => [detail_text],
               :error => [error],
               :start_test => [test_title],
               :finish_test => [test_title, result],
               :skip_test => [test_title],
               :enter_context => [context_title],
               :exit_context => [context_title, result],
-              :skip_context => [context_title]
+              :skip_context => [context_title],
+              :finish => [result]
             }.each(&block)
           end
         end

data/lib/test_bench/fixture/controls/output/log.rb

@@ -0,0 +1,45 @@
+module TestBench
+  module Fixture
+    module Controls
+      module Output
+        module Log
+          module Level
+            def self.example
+              fatal
+            end
+
+            def self.unknown
+              :unknown
+            end
+
+            def self.fatal
+              :fatal
+            end
+
+            def self.error
+              :error
+            end
+
+            def self.warning
+              :warning
+            end
+
+            def self.info
+              :info
+            end
+
+            def self.debug
+              :debug
+            end
+
+            module Invalid
+              def self.example
+                :not_a_log_level
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/fixture/fixture.rb

@@ -3,6 +3,8 @@ module TestBench
     Error = Class.new(RuntimeError)
 
     def self.build(cls, *args, session: nil, output: nil, error_policy: nil, factory_method: nil, **kwargs, &block)
+      assure_fixture(cls)
+
       factory_method = factory_method(cls)
 
       if kwargs.empty?
@@ -16,6 +18,12 @@ module TestBench
       instance
     end
 
+    def self.assure_fixture(cls)
+      unless cls.included_modules.include?(self)
+        raise Error, "Not a fixture class (Class: #{cls.inspect})"
+      end
+    end
+
     def self.factory_method(cls)
       if cls.respond_to?(:build)
         cls.method(:build)
@@ -54,19 +62,14 @@ module TestBench
       test_session.comment(text)
     end
 
-    ArgumentOmitted = Object.new
-    def assert(value=ArgumentOmitted, caller_location: nil, &block)
-      caller_location ||= caller_locations.first
+    def detail(text)
+      test_session.detail(text)
+    end
 
-      unless value == ArgumentOmitted
-        unless block.nil?
-          raise ArgumentError, "Must supply a boolean value or a block (but not both)"
-        end
+    def assert(value, caller_location: nil)
+      caller_location ||= caller_locations.first
 
-        test_session.assert(value, caller_location: caller_location)
-      else
-        test_session.assert_block(caller_location: caller_location, &block)
-      end
+      test_session.assert(value, caller_location: caller_location)
     end
 
     def refute(value, caller_location: nil)
@@ -85,24 +88,30 @@ module TestBench
 
       caller_location ||= caller_locations.first
 
-      assert(caller_location: caller_location) do
-        comment "Expected Error: #{error_class}#{' (strict)' if strict}"
-        comment "Expected Message: #{message.inspect}" unless message.nil?
+      detail "Expected Error: #{error_class}#{' (strict)' if strict}"
+      detail "Expected Message: #{message.inspect}" unless message.nil?
+
+      block.()
 
-        block.()
+      detail "(No error was raised)"
 
-        comment "(No error was raised)"
+      assert(false, caller_location: caller_location)
 
-      rescue error_class => error
+    rescue error_class => error
 
-        comment "Raised error: #{error.inspect}#{" (subclass of #{error_class})" if error.class < error_class}"
+      detail "Raised error: #{error.inspect}#{" (subclass of #{error_class})" if error.class < error_class}"
 
-        if strict && !error.instance_of?(error_class)
-          raise error
-        end
+      if strict && !error.instance_of?(error_class)
+        raise error
+      end
 
-        assert(message.nil? || error.message == message)
+      if message.nil?
+        result = true
+      else
+        result = error.message == message
       end
+
+      assert(result, caller_location: caller_location)
     end
 
     def refute_raises(error_class=nil, strict: nil, caller_location: nil, &block)
@@ -115,22 +124,27 @@ module TestBench
 
       caller_location ||= caller_locations.first
 
-      assert(caller_location: caller_location) do
-        comment "Prohibited Error: #{error_class}#{' (strict)' if strict}"
+      detail "Prohibited Error: #{error_class}#{' (strict)' if strict}"
+
+      block.()
 
-        block.()
+      detail "(No error was raised)"
 
-        comment "(No error was raised)"
+      result = true
 
-        assert(true)
+    rescue error_class => error
 
-      rescue error_class => error
+      detail "Raised Error: #{error.inspect}"
+
+      if strict && !error.instance_of?(error_class)
+        raise error
+      end
 
-        comment "Raised Error: #{error.inspect}"
+      result = false
 
-        if strict && !error.instance_of?(error_class)
-          raise error
-        end
+    ensure
+      unless result.nil?
+        assert(result, caller_location: caller_location)
       end
     end
 

data/lib/test_bench/fixture/output.rb

@@ -1,6 +1,10 @@
 module TestBench
   module Fixture
     module Output
+      def self.signals
+        instance_methods(false)
+      end
+
       def start
       end
 
@@ -22,13 +26,10 @@ module TestBench
       def assert(result, caller_location)
       end
 
-      def enter_assert_block(caller_location)
-      end
-
-      def exit_assert_block(result, caller_location)
+      def comment(text)
       end
 
-      def comment(text)
+      def detail(text)
       end
 
       def error(error)

data/lib/test_bench/fixture/output/capture.rb

@@ -0,0 +1,113 @@
+module TestBench
+  module Fixture
+    module Output
+      class Capture
+        include Fixture::Output
+
+        def records
+          @records ||= []
+        end
+
+        def current_context
+          @current_context ||= []
+        end
+
+        def start
+          record(:start)
+        end
+
+        def finish(result)
+          record(:finish, result)
+        end
+
+        def enter_file(path)
+          record(:enter_file, path)
+        end
+
+        def exit_file(path, result)
+          record(:exit_file, path, result)
+        end
+
+        def start_fixture(fixture)
+          record(:start_fixture, fixture)
+        end
+
+        def finish_fixture(fixture, result)
+          record(:finish_fixture, fixture, result)
+        end
+
+        def assert(result, caller_location)
+          record(:assert, result, caller_location)
+        end
+
+        def comment(text)
+          record(:comment, text)
+        end
+
+        def detail(text)
+          record(:detail, text)
+        end
+
+        def error(error)
+          record(:error, error)
+        end
+
+        def start_test(title)
+          record(:start_test, title)
+        end
+
+        def finish_test(title, result)
+          record(:finish_test, title, result)
+        end
+
+        def skip_test(title)
+          record(:skip_test, title)
+        end
+
+        def enter_context(title)
+          record = record(:enter_context, title)
+
+          unless title.nil?
+            current_context.push(title)
+          end
+
+          record
+        end
+
+        def exit_context(title, result)
+          unless title.nil?
+            current_context.pop
+          end
+
+          record(:exit_context, title, result)
+        end
+
+        def skip_context(title)
+          record(:skip_context, title)
+        end
+
+        def each_record(&block)
+          records.each(&block)
+        end
+
+        def record(signal, *data)
+          record = new_record(signal, data)
+          records << record
+          record
+        end
+
+        def new_record(signal, data)
+          context = current_context.dup
+
+          record = Record.new(signal, data, context)
+        end
+
+        Record = Struct.new(:signal, :data, :context) do
+          def forward(receiver)
+            receiver.public_send(signal, *data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/fixture/output/log.rb

@@ -4,28 +4,65 @@ module TestBench
       class Log
         include Output
 
+        Error = Class.new(RuntimeError)
+
         attr_reader :logger
 
         def initialize(logger)
           @logger = logger
         end
 
-        def self.build(device=nil)
+        def self.build(device=nil, level: nil)
           device ||= $stderr
+          level ||= self.default_level
+
+          level_ordinal = level_ordinal(level)
 
           logger = Logger.new(device)
+          logger.level = level_ordinal
 
           new(logger)
         end
 
-        def self.configure(receiver, device=nil, attr_name: nil)
+        def self.configure(receiver, device=nil, level: nil, attr_name: nil)
           attr_name ||= :output
 
-          instance = build(device)
+          instance = build(device, level: level)
           receiver.public_send(:"#{attr_name}=", instance)
           instance
         end
 
+        def self.default_level
+          :debug
+        end
+
+        def self.levels
+          level_ordinals.keys
+        end
+
+        def self.level_ordinal(level)
+          assure_level(level)
+
+          level_ordinals.fetch(level)
+        end
+
+        def self.level_ordinals
+          {
+            :unknown => Logger::Severity::UNKNOWN,
+            :fatal => Logger::Severity::FATAL,
+            :error => Logger::Severity::ERROR,
+            :warning => Logger::Severity::WARN,
+            :info => Logger::Severity::INFO,
+            :debug => Logger::Severity::DEBUG
+          }
+        end
+
+        def self.assure_level(level)
+          unless level_ordinals.key?(level)
+            raise Error, "Unknown log level #{level.inspect} (Valid levels: #{levels.map(&:inspect) * ', '})"
+          end
+        end
+
         def start
           logger.debug { "Start" }
         end
@@ -54,18 +91,14 @@ module TestBench
           logger.info { "Assertion (Result: #{result}, Caller Location: #{caller_location})" }
         end
 
-        def enter_assert_block(caller_location)
-          logger.debug { "Entering assert block (Caller Location: #{caller_location})" }
-        end
-
-        def exit_assert_block(caller_location, result)
-          logger.info { "Exited assert block (Caller Location: #{caller_location}, Result: #{result})" }
-        end
-
         def comment(text)
           logger.info { "Comment (Text: #{text})" }
         end
 
+        def detail(text)
+          logger.debug { "Detail (Text: #{text})" }
+        end
+
         def error(error)
           logger.error { "Error (Error: #{error})" }
         end

data/lib/test_bench/fixture/output/substitute.rb

@@ -8,132 +8,105 @@ module TestBench
 
         MatchError = Class.new(RuntimeError)
 
-        class Output
-          include Fixture::Output
+        class Output < Capture
+          alias_method :raw_records, :records
 
-          def records
-            @records ||= []
-          end
-
-          def start
-            record(:start)
-          end
+          def scope(*contexts, &block)
+            records = records(*contexts, &block)
 
-          def finish(result)
-            record(:finish, result)
+            Scope.build(records)
           end
 
-          def enter_file(path)
-            record(:enter_file, path)
-          end
+          def recorded_once?(*contexts, &block)
+            record = one_record(*contexts, &block)
 
-          def exit_file(path, result)
-            record(:exit_file, path, result)
+            record ? true : false
           end
 
-          def start_fixture(fixture)
-            record(:start_fixture, fixture)
-          end
+          def recorded?(*contexts, &block)
+            records = match_records(*contexts, &block)
 
-          def finish_fixture(fixture, result)
-            record(:finish_fixture, fixture, result)
+            records.any?
           end
 
-          def assert(result, caller_location)
-            record(:assert, result, caller_location)
-          end
+          def one_record(*contexts, &block)
+            matching_records = match_records(*contexts, &block)
 
-          def enter_assert_block(caller_location)
-            record(:enter_assert_block, caller_location)
-          end
-
-          def exit_assert_block(caller_location, result)
-            record(:exit_assert_block, caller_location, result)
-          end
-
-          def comment(text)
-            record(:comment, text)
-          end
+            return if matching_records.empty?
 
-          def error(error)
-            record(:error, error)
-          end
+            unless matching_records.one?
+              raise MatchError, "More than one records match"
+            end
 
-          def start_test(title)
-            record(:start_test, title)
+            matching_records.shift
           end
 
-          def finish_test(title, result)
-            record(:finish_test, title, result)
-          end
+          def records(*contexts, &block)
+            if contexts.empty? && block.nil?
+              return raw_records
+            end
 
-          def skip_test(title)
-            record(:skip_test, title)
+            match_records(*contexts, &block)
           end
 
-          def enter_context(title)
-            record(:enter_context, title)
-          end
+          def match_records(*contexts, &block)
+            block ||= proc { true }
 
-          def exit_context(title, result)
-            record(:exit_context, title, result)
-          end
+            raw_records.select do |record|
+              context_iterator = record.context.to_enum
 
-          def skip_context(title)
-            record(:skip_context, title)
-          end
+              contexts_match = contexts.all? do |context|
+                until context_iterator.peek == context
+                  context_iterator.next
+                end
+                true
 
-          def record(signal, *data)
-            record = Record.new(signal, data)
-            records << record
-            record
-          end
+              rescue StopIteration
+                false
+              end
 
-          def replay_records(output)
-            records.each do |record|
-              output.public_send(record.signal, *record.data)
+              contexts_match &&
+                block.(record.signal, *record.data, record.context)
             end
           end
 
-          def recorded?(signal=nil, &block)
-            matching_records(signal, &block).any?
-          end
-
-          def recorded_once?(signal=nil, &block)
-            one_record(signal, &block) ? true : false
-          end
-
-          def one_record(signal=nil, &block)
-            matching_records = matching_records(signal, &block)
-
-            return if matching_records.empty?
-
-            unless matching_records.one?
-              raise MatchError, "More than one records match"
+          Fixture::Output.signals.each do |signal|
+            signal_records_method = :"#{signal}_records" # e.g. comment_records
+            define_method(signal_records_method) do |*contexts, &block|
+              match_records(*contexts) do |recorded_signal, *data|
+                if recorded_signal == signal
+                  block.nil? || block.(*data)
+                end
+              end
             end
 
-            matching_records.shift
-          end
-
-          def matching_records(signal=nil, &block)
-            unless signal.nil?
-              inner_block = block || proc { true }
+            one_signal_method = :"one_#{signal}_record" # e.g. one_comment_record
+            define_method(one_signal_method) do |*contexts, &block|
+              one_record(*contexts) do |recorded_signal, *data|
+                if recorded_signal == signal
+                  block.nil? || block.(*data)
+                end
+              end
+            end
 
-              block = proc { |sig, *data|
-                if sig == signal
-                  inner_block.(*data)
-                else
-                  false
+            signal_recorded_method = :"#{signal}_recorded?" # e.g. comment_recorded?
+            define_method(signal_recorded_method) do |*contexts, &block|
+              recorded?(*contexts) do |recorded_signal, *data|
+                if recorded_signal == signal
+                  block.nil? || block.(*data)
                 end
-              }
+              end
             end
 
-            records.select do |record|
-              block.(record.signal, *record.data)
+            signal_recorded_once_method = :"#{signal}_recorded_once?" # e.g. comment_recorded_once?
+            define_method(signal_recorded_once_method) do |*contexts, &block|
+              recorded_once?(*contexts) do |recorded_signal, *data|
+                if recorded_signal == signal
+                  block.nil? || block.(*data)
+                end
+              end
             end
           end
-
-          Record = Struct.new(:signal, :data)
         end
       end
     end

data/lib/test_bench/fixture/output/substitute/scope.rb

@@ -0,0 +1,26 @@
+module TestBench
+  module Fixture
+    module Output
+      module Substitute
+        class Output
+          class Scope < Output
+            attr_writer :records
+
+            def self.build(records)
+              instance = new
+              instance.records = records
+              instance
+            end
+
+            def combine(scope)
+              combined_records = self.records + scope.records
+
+              Scope.build(combined_records)
+            end
+            alias_method :+, :combine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/fixture/session.rb

@@ -13,6 +13,12 @@ module TestBench
       end
       attr_writer :error_counter
 
+      def skip
+        @skip ||= false
+      end
+      attr_writer :skip
+      alias_method :skip?, :skip
+
       def started
         instance_variable_defined?(:@started) ?
           @started :
@@ -95,6 +101,10 @@ module TestBench
         output.comment(text)
       end
 
+      def detail(text)
+        output.detail(text)
+      end
+
       def error(error)
         fail!
 
@@ -122,35 +132,6 @@ module TestBench
         result
       end
 
-      def assert_block(caller_location: nil, &block)
-        caller_location ||= caller_locations.first
-
-        previous_error_counter = self.error_counter
-        previous_assertion_counter = self.assertion_counter
-
-        output.enter_assert_block(caller_location)
-
-        begin
-          block.()
-
-        ensure
-          if self.error_counter > previous_error_counter
-            result = false
-          elsif self.assertion_counter == previous_assertion_counter
-            result = false
-          else
-            result = true
-          end
-
-          output.exit_assert_block(caller_location, result)
-
-          current_exception = $!
-          if current_exception.nil? || current_exception.instance_of?(AssertionFailure)
-            assert(result, caller_location: caller_location)
-          end
-        end
-      end
-
       def load(path)
         output.enter_file(path)
 
@@ -171,7 +152,17 @@ module TestBench
 
         output.start_test(title)
 
-        evaluate(block) do |result|
+        previous_assertion_counter = self.assertion_counter
+
+        action = proc {
+          block.()
+
+          unless assertion_counter > previous_assertion_counter
+            raise Error, "Test did not perform an assertion"
+          end
+        }
+
+        evaluate(action) do |result|
           output.finish_test(title, result)
         end
       end
@@ -235,12 +226,17 @@ module TestBench
       end
 
       def fail!
+        self.assertion_counter += 1
         self.error_counter += 1
       end
 
       def failed?
         error_counter.nonzero? ? true : false
       end
+
+      def skip!
+        self.skip = true
+      end
     end
   end
 end

data/lib/test_bench/fixture/session/substitute.rb

@@ -7,117 +7,118 @@ module TestBench
         end
 
         class Session < Session
-          Error = Class.new(RuntimeError)
+          def scope(*contexts)
+            scoped_output = output.scope(*contexts)
 
-          attr_accessor :load_failure
+            return nil if scoped_output.records.empty?
 
-          def commented?(text)
-            output.recorded?(:comment) do |t|
-              t == text
-            end
+            scoped_session = self.class.new
+            scoped_session.output = scoped_output
+            scoped_session
           end
+          alias_method :[], :scope
 
-          def asserted?(result=nil, caller_location: nil)
-            output.recorded?(:assert) do |r, cl|
-              (result.nil? || r == result) &&
-              (caller_location.nil? || cl == caller_location)
+          def context?(*outer_contexts, title)
+            output.exit_context_recorded_once?(*outer_contexts) do |t|
+              t == title
             end
           end
 
-          def load_failure!
-            self.load_failure = true
+          def one_test_passed?(*contexts, title)
+            one_test?(*contexts, title) do |_, result|
+              result == true
+            end
           end
 
-          def load(path)
-            result = load_failure ? false : true
-
-            output.enter_file(path)
+          def one_test_failed?(*contexts, title)
+            one_test?(*contexts, title) do |_, result|
+              result == false
+            end
+          end
 
-            output.exit_file(path, result)
+          def one_test?(*contexts, title, &block)
+            test_scope = test_scope(*contexts, title)
 
-            result
+            test_scope.finish_test_recorded_once?(&block)
           end
 
-          def loaded?(path)
-            output.recorded?(:exit_file) do |p|
-              p == path
+          def any_test_passed?(*contexts, title)
+            any_test?(*contexts, title) do |_, result|
+              result == true
             end
           end
+          alias_method :test_passed?, :any_test_passed?
 
-          def test?(title)
-            output.recorded?(:finish_test) do |t|
-              t == title
+          def any_test_failed?(*contexts, title)
+            any_test?(*contexts, title) do |_, result|
+              result == false
             end
           end
+          alias_method :test_failed?, :any_test_failed?
 
-          def context?(title)
-            output.recorded?(:exit_context) do |t|
-              t == title
-            end
+          def any_test?(*contexts, title, &block)
+            test_scope = test_scope(*contexts, title)
+
+            test_scope.finish_test_recorded?(&block)
           end
+          alias_method :test?, :any_test?
 
-          def fixture?(fixture)
-            output.recorded?(:finish_fixture) do |f|
-              f == fixture
+          def commented?(*contexts, text)
+            output.comment_recorded?(*contexts) do |t|
+              t == text
             end
           end
 
-          def passed?(*titles)
-            !pass(*titles).nil?
+          def detail?(*contexts, text)
+            output.detail_recorded?(*contexts) do |t|
+              t == text
+            end
           end
 
-          def failed?(*titles)
-            return super if titles.empty?
+          def asserted?(*contexts, result: nil, caller_location: nil)
+            output.assert_recorded?(*contexts) do |r, cl|
+              result_match = result.nil? || r == result
+              caller_location_match = caller_location.nil? || cl == caller_location
 
-            !failure(*titles).nil?
+              result_match && caller_location_match
+            end
           end
 
-          def one_pass(*titles)
-            passes = passes(*titles)
-
-            if passes.count > 1
-              raise Error, "Multiple passing tests match (Titles: #{titles.inspect})"
-            end
+          def load(path)
+            output.enter_file(path)
 
-            passes.first
-          end
+            inert_action = proc { }
+            result = evaluate(inert_action)
 
-          def one_passed?(*titles)
-            one_pass(*titles) ? true : false
-          end
+            output.exit_file(path, result)
 
-          def pass(*titles)
-            passes(*titles).first
+            result
           end
 
-          def passes(*titles)
-            match_tests(*titles, result: true)
+          def loaded?(path=nil)
+            output.enter_file_recorded? do |p|
+              path.nil? || p == path
+            end
           end
 
-          def one_failure(*titles)
-            failures = failures(*titles)
-
-            if failures.count > 1
-              raise Error, "Multiple failing tests match (Titles: #{titles.inspect})"
+          def fixture?(fixture)
+            output.finish_fixture_recorded? do |f|
+              f == fixture
             end
-
-            failures.first
           end
 
-          def one_failed?(*titles)
-            one_failure(*titles) ? true : false
-          end
+          def test_scope(*contexts, title)
+            context_scope = output.scope(*contexts)
 
-          def failure(*titles)
-            failures(*titles).first
-          end
+            titled_test_scope = context_scope.scope do |signal, t|
+              signal == :finish_test && t == title
+            end
 
-          def failures(*titles)
-            match_tests(*titles, result: false)
-          end
+            untitled_test_scope = context_scope.scope(title) do |signal, t|
+              signal == :finish_test && t.nil?
+            end
 
-          def match_tests(*titles, result: nil)
-            MatchTests.(self, *titles, result: result)
+            titled_test_scope + untitled_test_scope
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: test_bench-fixture
 version: !ruby/object:Gem::Version
-  version: 1.0.0.0
+  version: 1.2.1.1
 platform: ruby
 authors:
 - Nathan Ladd
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-09 00:00:00.000000000 Z
+date: 2020-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test_bench-bootstrap
@@ -24,7 +24,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email: nathanladd+github@gmail.com
 executables: []
 extensions: []
@@ -38,23 +38,25 @@ files:
 - lib/test_bench/fixture/controls/error/backtrace.rb
 - lib/test_bench/fixture/controls/fixture.rb
 - lib/test_bench/fixture/controls/output.rb
+- lib/test_bench/fixture/controls/output/log.rb
 - lib/test_bench/fixture/controls/result.rb
 - lib/test_bench/fixture/controls/test_file.rb
 - lib/test_bench/fixture/error_policy.rb
 - lib/test_bench/fixture/fixture.rb
 - lib/test_bench/fixture/output.rb
+- lib/test_bench/fixture/output/capture.rb
 - lib/test_bench/fixture/output/log.rb
 - lib/test_bench/fixture/output/multiple.rb
 - lib/test_bench/fixture/output/null.rb
 - lib/test_bench/fixture/output/substitute.rb
+- lib/test_bench/fixture/output/substitute/scope.rb
 - lib/test_bench/fixture/session.rb
 - lib/test_bench/fixture/session/substitute.rb
-- lib/test_bench/fixture/session/substitute/match_tests.rb
 homepage: https://github.com/test-bench/test-bench-fixture
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -69,8 +71,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Test object framework
 test_files: []

data/lib/test_bench/fixture/session/substitute/match_tests.rb

@@ -1,131 +0,0 @@
-module TestBench
-  module Fixture
-    class Session
-      module Substitute
-        class MatchTests
-          include Output
-
-          attr_reader :output_substitute
-          attr_reader :patterns
-          attr_reader :result
-
-          def matches
-            @matches ||= []
-          end
-
-          def stack
-            @stack ||= []
-          end
-
-          def pattern_index
-            @pattern_index ||= 0
-          end
-          attr_writer :pattern_index
-
-          def initialize(output_substitute, result, *patterns)
-            @output_substitute = output_substitute
-            @result = result
-            @patterns = patterns
-          end
-
-          def self.build(run, *patterns, result: nil)
-            output_substitute = run.output
-
-            patterns.map! do |pattern|
-              if pattern.is_a?(String)
-                Regexp.new("\\A#{Regexp.escape(pattern)}\\z")
-              else
-                pattern
-              end
-            end
-
-            new(output_substitute, result, *patterns)
-          end
-
-          def self.call(run, *patterns, result: nil)
-            instance = build(run, *patterns, result: result)
-            instance.()
-          end
-
-          def call
-            output_substitute.replay_records(self)
-
-            matches
-          end
-
-          def enter_context(title)
-            push(title)
-          end
-
-          def exit_context(_, _)
-            pop
-          end
-
-          def finish_test(title, result)
-            push(title)
-
-            if match?(result)
-              text = stack.join("\t")
-
-              matches << text
-            end
-
-            pop unless title.nil?
-          end
-
-          def skip_test(title)
-            push(title)
-
-            pop
-          end
-
-          def push(title)
-            return if title.nil?
-
-            if next_pattern.match?(title)
-              self.pattern_index += 1
-            end
-
-            stack.push(title)
-          end
-
-          def pop
-            title = stack.pop
-
-            if previous_pattern.match?(title)
-              self.pattern_index -= 1
-            end
-          end
-
-          def match?(result)
-            return false unless pattern_index == patterns.count
-
-            if self.result.nil?
-              true
-            else
-              result == self.result
-            end
-          end
-
-          def next_pattern
-            return Pattern.none if pattern_index == patterns.count
-
-            patterns.fetch(pattern_index)
-          end
-
-          def previous_pattern
-            return Pattern.none if pattern_index.zero?
-
-            patterns[pattern_index - 1]
-          end
-
-          module Pattern
-            def self.none
-              %r{\z\A}
-            end
-          end
-        end
-      end
-    end
-  end
-end