test_bench-fixture 1.0.0.0

data/lib/test_bench/fixture/session.rb

@@ -0,0 +1,246 @@
+module TestBench
+  module Fixture
+    class Session
+      Error = Class.new(RuntimeError)
+
+      def assertion_counter
+        @assertion_counter ||= 0
+      end
+      attr_writer :assertion_counter
+
+      def error_counter
+        @error_counter ||= 0
+      end
+      attr_writer :error_counter
+
+      def started
+        instance_variable_defined?(:@started) ?
+          @started :
+          @started = false
+      end
+      attr_writer :started
+      alias_method :started?, :started
+
+      def finished
+        instance_variable_defined?(:@finished) ?
+          @finished :
+          @finished = false
+      end
+      attr_writer :finished
+      alias_method :finished?, :finished
+
+      def error_policy
+        @error_policy ||= ErrorPolicy::Build.(:rescue_assert)
+      end
+      attr_writer :error_policy
+
+      def output
+        @output ||= Output::Substitute.build
+      end
+      attr_writer :output
+
+      def self.build(output: nil, error_policy: nil)
+        instance = new
+
+        if output.nil?
+          Output::Log.configure(instance)
+        else
+          instance.output = output
+        end
+
+        ErrorPolicy.configure(instance, policy: error_policy)
+
+        instance
+      end
+
+      def self.configure(receiver, session: nil, output: nil, error_policy: nil, attr_name: nil)
+        attr_name ||= :session
+
+        if session.nil?
+          instance = build(output: output, error_policy: error_policy)
+        else
+          instance = session
+        end
+
+        receiver.public_send(:"#{attr_name}=", instance)
+
+        instance
+      end
+
+      def start
+        if started
+          raise Error, "Session has already been started"
+        end
+
+        self.started = true
+
+        output.start
+      end
+
+      def finish
+        if finished
+          raise Error, "Session has already finished"
+        end
+
+        self.finished = true
+
+        result = !failed?
+
+        output.finish(result)
+
+        result
+      end
+
+      def comment(text)
+        output.comment(text)
+      end
+
+      def error(error)
+        fail!
+
+        output.error(error)
+
+        error_policy.(error)
+      end
+
+      def assert(value, caller_location: nil)
+        caller_location ||= caller_locations.first
+
+        result = value ? true : false
+
+        self.assertion_counter += 1
+
+        output.assert(result, caller_location)
+
+        unless result
+          self.error_counter += 1
+
+          assertion_failure = AssertionFailure.build(caller_location)
+          raise assertion_failure
+        end
+
+        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)
+
+        action = proc { Kernel.load(path) }
+
+        result = evaluate(action)
+
+        output.exit_file(path, result)
+
+        result
+      end
+
+      def test(title=nil, &block)
+        if block.nil?
+          output.skip_test(title)
+          return
+        end
+
+        output.start_test(title)
+
+        evaluate(block) do |result|
+          output.finish_test(title, result)
+        end
+      end
+
+      def context(title=nil, &block)
+        if block.nil?
+          output.skip_context(title)
+          return
+        end
+
+        output.enter_context(title)
+
+        evaluate(block) do |result|
+          output.exit_context(title, result)
+        end
+      end
+
+      def fixture(fixture, &block)
+        if block.nil? && !fixture.respond_to?(:call)
+          raise Error, "Block must be given when a fixture does not respond to #call"
+        end
+
+        actions = []
+
+        if fixture.respond_to?(:call)
+          actions << fixture
+        end
+
+        unless block.nil?
+          actions << proc { block.(fixture) }
+        end
+
+        output.start_fixture(fixture)
+
+        action = proc { actions.each(&:call) }
+        result = evaluate(action)
+
+        output.finish_fixture(fixture, result)
+
+        result
+      end
+
+      def evaluate(action, &block)
+        previous_error_counter = self.error_counter
+
+        begin
+          action.()
+
+        rescue => error
+          error(error)
+
+        ensure
+          current_exception = $!
+
+          result = error_counter == previous_error_counter
+
+          block.(result, current_exception) unless block.nil?
+        end
+
+        result
+      end
+
+      def fail!
+        self.error_counter += 1
+      end
+
+      def failed?
+        error_counter.nonzero? ? true : false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,126 @@
+module TestBench
+  module Fixture
+    class Session
+      module Substitute
+        def self.build
+          Session.new
+        end
+
+        class Session < Session
+          Error = Class.new(RuntimeError)
+
+          attr_accessor :load_failure
+
+          def commented?(text)
+            output.recorded?(:comment) do |t|
+              t == text
+            end
+          end
+
+          def asserted?(result=nil, caller_location: nil)
+            output.recorded?(:assert) do |r, cl|
+              (result.nil? || r == result) &&
+              (caller_location.nil? || cl == caller_location)
+            end
+          end
+
+          def load_failure!
+            self.load_failure = true
+          end
+
+          def load(path)
+            result = load_failure ? false : true
+
+            output.enter_file(path)
+
+            output.exit_file(path, result)
+
+            result
+          end
+
+          def loaded?(path)
+            output.recorded?(:exit_file) do |p|
+              p == path
+            end
+          end
+
+          def test?(title)
+            output.recorded?(:finish_test) do |t|
+              t == title
+            end
+          end
+
+          def context?(title)
+            output.recorded?(:exit_context) do |t|
+              t == title
+            end
+          end
+
+          def fixture?(fixture)
+            output.recorded?(:finish_fixture) do |f|
+              f == fixture
+            end
+          end
+
+          def passed?(*titles)
+            !pass(*titles).nil?
+          end
+
+          def failed?(*titles)
+            return super if titles.empty?
+
+            !failure(*titles).nil?
+          end
+
+          def one_pass(*titles)
+            passes = passes(*titles)
+
+            if passes.count > 1
+              raise Error, "Multiple passing tests match (Titles: #{titles.inspect})"
+            end
+
+            passes.first
+          end
+
+          def one_passed?(*titles)
+            one_pass(*titles) ? true : false
+          end
+
+          def pass(*titles)
+            passes(*titles).first
+          end
+
+          def passes(*titles)
+            match_tests(*titles, result: true)
+          end
+
+          def one_failure(*titles)
+            failures = failures(*titles)
+
+            if failures.count > 1
+              raise Error, "Multiple failing tests match (Titles: #{titles.inspect})"
+            end
+
+            failures.first
+          end
+
+          def one_failed?(*titles)
+            one_failure(*titles) ? true : false
+          end
+
+          def failure(*titles)
+            failures(*titles).first
+          end
+
+          def failures(*titles)
+            match_tests(*titles, result: false)
+          end
+
+          def match_tests(*titles, result: nil)
+            MatchTests.(self, *titles, result: result)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+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