test_bench-fixture 1.4.0.1 → 2.1.0.0.pre1

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

@@ -1,127 +0,0 @@
-module TestBench
-  module Fixture
-    class Session
-      module Substitute
-        def self.build
-          Session.new
-        end
-
-        class Session < Session
-          def scope(*contexts)
-            scoped_output = output.scope(*contexts)
-
-            return nil if scoped_output.records.empty?
-
-            scoped_session = self.class.new
-            scoped_session.output = scoped_output
-            scoped_session
-          end
-          alias_method :[], :scope
-
-          def context?(*outer_contexts, title)
-            output.exit_context_recorded_once?(*outer_contexts) do |t|
-              t == title
-            end
-          end
-
-          def one_test_passed?(*contexts, title)
-            one_test?(*contexts, title) do |_, result|
-              result == true
-            end
-          end
-
-          def one_test_failed?(*contexts, title)
-            one_test?(*contexts, title) do |_, result|
-              result == false
-            end
-          end
-
-          def one_test?(*contexts, title, &block)
-            test_scope = test_scope(*contexts, title)
-
-            test_scope.finish_test_recorded_once?(&block)
-          end
-
-          def any_test_passed?(*contexts, title)
-            any_test?(*contexts, title) do |_, result|
-              result == true
-            end
-          end
-          alias_method :test_passed?, :any_test_passed?
-
-          def any_test_failed?(*contexts, title)
-            any_test?(*contexts, title) do |_, result|
-              result == false
-            end
-          end
-          alias_method :test_failed?, :any_test_failed?
-
-          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 commented?(*contexts, text)
-            output.comment_recorded?(*contexts) do |t|
-              t == text
-            end
-          end
-
-          def detail?(*contexts, text)
-            output.detail_recorded?(*contexts) do |t|
-              t == text
-            end
-          end
-
-          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
-
-              result_match && caller_location_match
-            end
-          end
-
-          def load(path)
-            output.enter_file(path)
-
-            inert_action = proc { }
-            result = evaluate(inert_action)
-
-            output.exit_file(path, result)
-
-            result
-          end
-
-          def loaded?(path=nil)
-            output.enter_file_recorded? do |p|
-              path.nil? || p == path
-            end
-          end
-
-          def fixture?(fixture)
-            output.finish_fixture_recorded? do |f|
-              f == fixture
-            end
-          end
-
-          def test_scope(*contexts, title)
-            context_scope = output.scope(*contexts)
-
-            titled_test_scope = context_scope.scope do |signal, t|
-              signal == :finish_test && t == title
-            end
-
-            untitled_test_scope = context_scope.scope(title) do |signal, t|
-              signal == :finish_test && t.nil?
-            end
-
-            titled_test_scope + untitled_test_scope
-          end
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/fixture/session.rb

@@ -1,249 +0,0 @@
-module TestBench
-  module Fixture
-    class Session
-      Error = Class.new(RuntimeError)
-      Abort = Class.new(RuntimeError)
-
-      def assertion_counter
-        @assertion_counter ||= 0
-      end
-      attr_writer :assertion_counter
-
-      def failure_counter
-        @failure_counter ||= 0
-      end
-      attr_writer :failure_counter
-
-      def skip_counter
-        @skip_counter ||= 0
-      end
-      attr_writer :skip_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::RescueAssert.new
-      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 detail(text)
-        output.detail(text)
-      end
-
-      def assert(value, caller_location: nil)
-        caller_location ||= caller[0]
-
-        result = value ? true : false
-
-        self.assertion_counter += 1
-
-        output.assert(result, caller_location)
-
-        unless result
-          assertion_failure = AssertionFailure.build(caller_location)
-          raise assertion_failure
-        end
-
-        result
-      end
-
-      def load(path)
-        output.enter_file(path)
-
-        result = false
-
-        Kernel.load(path)
-
-        result = true
-
-      ensure
-
-        output.exit_file(path, result)
-      end
-
-      def test(title=nil, &block)
-        if block.nil?
-          record_skip
-          output.skip_test(title)
-          return
-        end
-
-        output.start_test(title)
-
-        previous_failure_counter = self.failure_counter
-        previous_assertion_counter = self.assertion_counter
-
-        action = ->{
-          block.()
-
-          if failure_counter == previous_failure_counter
-            if assertion_counter == previous_assertion_counter
-              raise Error, "Test did not perform an assertion"
-            end
-          end
-        }
-
-        evaluate(action) do |result|
-          output.finish_test(title, result)
-        end
-      end
-
-      def context(title=nil, &block)
-        if block.nil?
-          record_skip
-          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) do |result|
-          output.finish_fixture(fixture, result)
-        end
-
-        result
-      end
-
-      def evaluate(action, &block)
-        previous_failure_counter = self.failure_counter
-
-        begin
-          action.()
-
-        rescue Abort
-
-        rescue => error
-          record_failure
-
-          output.error(error)
-
-          error_policy.(error)
-          error = nil
-
-        ensure
-          result = failure_counter == previous_failure_counter
-
-          block.(result, error) unless block.nil?
-        end
-
-        result
-      end
-
-      def record_failure
-        self.failure_counter += 1
-      end
-      alias_method :fail!, :record_failure
-
-      def failed?
-        failure_counter.nonzero? ? true : false
-      end
-
-      def record_skip
-        self.skip_counter += 1
-      end
-
-      def skipped?
-        skip_counter.nonzero? ? true : false
-      end
-    end
-  end
-end