test_bench-fixture 1.0.0.0

data/lib/test_bench/fixture/error_policy.rb

@@ -0,0 +1,75 @@
+module TestBench
+  module Fixture
+    module ErrorPolicy
+      def self.configure(receiver, policy: nil, attr_name: nil)
+        attr_name ||= :error_policy
+
+        instance = Build.(policy)
+        receiver.public_send(:"#{attr_name}=", instance)
+        instance
+      end
+
+      module Build
+        PolicyError = Class.new(RuntimeError)
+
+        def self.call(policy=nil)
+          cls = policy_class(policy)
+
+          cls.new
+        end
+
+        def self.policy_class(policy=nil)
+          policy ||= Defaults.policy
+
+          policies.fetch(policy) do
+            *policies, final_policy = self.policies.keys
+
+            policy_list = "#{policies.map(&:inspect) * ', '} or #{final_policy.inspect}"
+
+            raise PolicyError, "Policy #{policy.inspect} is unknown. It must be one of: #{policy_list}"
+          end
+        end
+
+        def self.policies
+          {
+            :abort => Abort,
+            :raise => Raise,
+            :rescue => Rescue,
+            :rescue_assert => RescueAssert
+          }
+        end
+
+        module Defaults
+          def self.policy
+            :rescue_assert
+          end
+        end
+      end
+
+      class Abort
+        def call(error)
+          abort "TestBench is aborting (#{self.class})"
+        end
+      end
+
+      class Raise
+        def call(error)
+          raise error
+        end
+      end
+
+      class Rescue
+        def call(error)
+        end
+      end
+
+      class RescueAssert
+        def call(error)
+          unless error.instance_of?(AssertionFailure)
+            raise error
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/fixture/fixture.rb

@@ -0,0 +1,149 @@
+module TestBench
+  module Fixture
+    Error = Class.new(RuntimeError)
+
+    def self.build(cls, *args, session: nil, output: nil, error_policy: nil, factory_method: nil, **kwargs, &block)
+      factory_method = factory_method(cls)
+
+      if kwargs.empty?
+        instance = factory_method.(*args, &block)
+      else
+        instance = factory_method.(*args, **kwargs, &block)
+      end
+
+      Session.configure(instance, session: session, output: output, error_policy: error_policy)
+
+      instance
+    end
+
+    def self.factory_method(cls)
+      if cls.respond_to?(:build)
+        cls.method(:build)
+      elsif cls.respond_to?(:new)
+        cls.method(:new)
+      else
+        raise Error, "Must be given a class (Argument: #{cls.inspect})"
+      end
+    end
+
+    def self.call(cls, *args, **kwargs, &block)
+      factory_method = factory_method(cls)
+
+      last_parameter_type, _ = factory_method.parameters.last
+
+      if last_parameter_type == :block
+        instance = build(cls, *args, **kwargs, &block)
+        block = nil
+      else
+        instance = build(cls, *args, **kwargs)
+      end
+
+      instance.test_session.fixture(instance, &block)
+
+      instance
+    end
+
+    def test_session
+      @test_session ||= Session::Substitute.build
+    end
+    attr_writer :test_session
+    alias_method :session, :test_session
+    alias_method :session=, :test_session=
+
+    def comment(text)
+      test_session.comment(text)
+    end
+
+    ArgumentOmitted = Object.new
+    def assert(value=ArgumentOmitted, caller_location: nil, &block)
+      caller_location ||= caller_locations.first
+
+      unless value == ArgumentOmitted
+        unless block.nil?
+          raise ArgumentError, "Must supply a boolean value or a block (but not both)"
+        end
+
+        test_session.assert(value, caller_location: caller_location)
+      else
+        test_session.assert_block(caller_location: caller_location, &block)
+      end
+    end
+
+    def refute(value, caller_location: nil)
+      caller_location ||= caller_locations.first
+
+      test_session.assert(!value, caller_location: caller_location)
+    end
+
+    def assert_raises(error_class=nil, message=nil, strict: nil, caller_location: nil, &block)
+      if error_class.nil?
+        strict ||= false
+        error_class = StandardError
+      else
+        strict = true if strict.nil?
+      end
+
+      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?
+
+        block.()
+
+        comment "(No error was raised)"
+
+      rescue error_class => error
+
+        comment "Raised error: #{error.inspect}#{" (subclass of #{error_class})" if error.class < error_class}"
+
+        if strict && !error.instance_of?(error_class)
+          raise error
+        end
+
+        assert(message.nil? || error.message == message)
+      end
+    end
+
+    def refute_raises(error_class=nil, strict: nil, caller_location: nil, &block)
+      if error_class.nil?
+        strict ||= false
+        error_class = StandardError
+      else
+        strict = true if strict.nil?
+      end
+
+      caller_location ||= caller_locations.first
+
+      assert(caller_location: caller_location) do
+        comment "Prohibited Error: #{error_class}#{' (strict)' if strict}"
+
+        block.()
+
+        comment "(No error was raised)"
+
+        assert(true)
+
+      rescue error_class => error
+
+        comment "Raised Error: #{error.inspect}"
+
+        if strict && !error.instance_of?(error_class)
+          raise error
+        end
+      end
+    end
+
+    def context(text=nil, &block)
+      test_session.context(text, &block)
+    end
+
+    def test(text=nil, &block)
+      test_session.test(text, &block)
+    end
+
+    def fixture(cls, *args, **kwargs, &block)
+      Fixture.(cls, *args, session: test_session, **kwargs, &block)
+    end
+  end
+end

data/lib/test_bench/fixture/output.rb

@@ -0,0 +1,56 @@
+module TestBench
+  module Fixture
+    module Output
+      def start
+      end
+
+      def finish(result)
+      end
+
+      def enter_file(path)
+      end
+
+      def exit_file(path, result)
+      end
+
+      def start_fixture(fixture)
+      end
+
+      def finish_fixture(fixture, result)
+      end
+
+      def assert(result, caller_location)
+      end
+
+      def enter_assert_block(caller_location)
+      end
+
+      def exit_assert_block(result, caller_location)
+      end
+
+      def comment(text)
+      end
+
+      def error(error)
+      end
+
+      def start_test(title)
+      end
+
+      def finish_test(title, result)
+      end
+
+      def skip_test(title)
+      end
+
+      def enter_context(title)
+      end
+
+      def exit_context(title, result)
+      end
+
+      def skip_context(title)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+module TestBench
+  module Fixture
+    module Output
+      class Log
+        include Output
+
+        attr_reader :logger
+
+        def initialize(logger)
+          @logger = logger
+        end
+
+        def self.build(device=nil)
+          device ||= $stderr
+
+          logger = Logger.new(device)
+
+          new(logger)
+        end
+
+        def self.configure(receiver, device=nil, attr_name: nil)
+          attr_name ||= :output
+
+          instance = build(device)
+          receiver.public_send(:"#{attr_name}=", instance)
+          instance
+        end
+
+        def start
+          logger.debug { "Start" }
+        end
+
+        def finish(result)
+          logger.info { "Finish (Result: #{result})" }
+        end
+
+        def enter_file(path)
+          logger.debug { "Enter file (Path: #{path})" }
+        end
+
+        def exit_file(path, result)
+          logger.info { "Exit file (Path: #{path}, Result: #{result})" }
+        end
+
+        def start_fixture(fixture)
+          logger.debug { "Start fixture (Fixture: #{fixture.inspect})" }
+        end
+
+        def finish_fixture(fixture, result)
+          logger.info { "Finish fixture (Fixture: #{fixture.inspect}, Result: #{result})" }
+        end
+
+        def assert(result, caller_location)
+          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 error(error)
+          logger.error { "Error (Error: #{error})" }
+        end
+
+        def start_test(title)
+          logger.debug { "Starting test (Title: #{title || '(none)'})" }
+        end
+
+        def finish_test(title, result)
+          logger.info { "Finished test (Title: #{title || '(none)'}, Result: #{result})" }
+        end
+
+        def skip_test(title)
+          logger.info { "Skipped test (Title: #{title || '(none)'})" }
+        end
+
+        def enter_context(title)
+          logger.debug { "Entering context (Title: #{title || '(none)'})" }
+        end
+
+        def exit_context(title, result)
+          logger.info { "Exited context (Title: #{title || '(none)'}, Result: #{result})" }
+        end
+
+        def skip_context(title)
+          logger.info { "Skipped context (Title: #{title || '(none)'})" }
+        end
+
+        def device?(device)
+          self.device == device
+        end
+
+        def device
+          logger.instance_exec do
+            @logdev.dev
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module TestBench
+  module Fixture
+    module Output
+      class Multiple
+        include Output
+
+        def outputs
+          @outputs ||= []
+        end
+        attr_writer :outputs
+
+        def self.build(*outputs)
+          outputs = Array(outputs)
+
+          instance = new
+
+          outputs.each do |output|
+            instance.register(output)
+          end
+
+          instance
+        end
+
+        Output.instance_methods.each do |method_name|
+          define_method(method_name) do |*args|
+            outputs.map do |output|
+              output.public_send(method_name, *args)
+            end
+          end
+        end
+
+        def register(output)
+          outputs << output
+        end
+
+        def registered?(output)
+          outputs.include?(output)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module TestBench
+  module Fixture
+    module Output
+      class Null
+        include Output
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+module TestBench
+  module Fixture
+    module Output
+      module Substitute
+        def self.build
+          Output.new
+        end
+
+        MatchError = Class.new(RuntimeError)
+
+        class Output
+          include Fixture::Output
+
+          def records
+            @records ||= []
+          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 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
+
+          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(:enter_context, title)
+          end
+
+          def exit_context(title, result)
+            record(:exit_context, title, result)
+          end
+
+          def skip_context(title)
+            record(:skip_context, title)
+          end
+
+          def record(signal, *data)
+            record = Record.new(signal, data)
+            records << record
+            record
+          end
+
+          def replay_records(output)
+            records.each do |record|
+              output.public_send(record.signal, *record.data)
+            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"
+            end
+
+            matching_records.shift
+          end
+
+          def matching_records(signal=nil, &block)
+            unless signal.nil?
+              inner_block = block || proc { true }
+
+              block = proc { |sig, *data|
+                if sig == signal
+                  inner_block.(*data)
+                else
+                  false
+                end
+              }
+            end
+
+            records.select do |record|
+              block.(record.signal, *record.data)
+            end
+          end
+
+          Record = Struct.new(:signal, :data)
+        end
+      end
+    end
+  end
+end