test_bench-fixture 1.4.0.2 → 2.1.0.0.pre1

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

@@ -1,77 +0,0 @@
-module TestBench
-  module Fixture
-    module Controls
-      module TestFile
-        def self.example(filename: nil, text: nil, directory: nil)
-          filename ||= self.filename
-          text ||= self.text
-          directory ||= self.directory
-
-          basename, extension, _ = filename.partition('.rb')
-
-          file = Tempfile.new([basename, extension], directory)
-          file.write(text)
-          file.close
-
-          tempfiles << file
-
-          file.path
-        end
-
-        def self.filename
-          'some_test_file.rb'
-        end
-
-        def self.path
-          "test/automated/#{filename}"
-        end
-
-        def self.text
-          '# Nothing'
-        end
-
-        def self.directory
-          '/tmp'
-        end
-
-        def self.tempfiles
-          @tempfiles ||= []
-        end
-
-        module Alternate
-          def self.example
-            TestFile.example(filename: filename)
-          end
-
-          def self.filename
-            'other_test_file.rb'
-          end
-        end
-
-        module Pass
-          def self.example(directory: nil)
-            TestFile.example(filename: filename, directory: directory)
-          end
-
-          def self.filename
-            'some_passing_test.rb'
-          end
-        end
-
-        module Failure
-          def self.example(directory: nil)
-            TestFile.example(text: text, filename: filename, directory: directory)
-          end
-
-          def self.filename
-            'some_failing_test.rb'
-          end
-
-          def self.text
-            "raise #{Error.name}.example"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/fixture/error_policy.rb

@@ -1,75 +0,0 @@
-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).join(', ')} 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/output/capture.rb

@@ -1,131 +0,0 @@
-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.build(signal, data, context)
-        end
-
-        class Record
-          attr_accessor :signal
-          attr_accessor :data
-          attr_accessor :context
-
-          def self.build(signal, data, context=nil)
-            instance = new
-            instance.signal = signal
-            instance.data = data
-            instance.context = context
-            instance
-          end
-
-          def forward(receiver)
-            receiver.public_send(signal, *data)
-          end
-
-          def ==(record)
-            self.signal == record.signal &&
-              self.data == record.data &&
-              self.context == record.context
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,142 +0,0 @@
-module TestBench
-  module Fixture
-    module Output
-      class Log
-        include Output
-
-        Error = Class.new(RuntimeError)
-
-        attr_reader :logger
-
-        def initialize(logger)
-          @logger = logger
-        end
-
-        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, level: nil, attr_name: nil)
-          attr_name ||= :output
-
-          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).join(', ')})"
-          end
-        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 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
-
-        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

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

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

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

@@ -1,26 +0,0 @@
-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/output/substitute.rb

@@ -1,114 +0,0 @@
-module TestBench
-  module Fixture
-    module Output
-      module Substitute
-        def self.build
-          Output.new
-        end
-
-        MatchError = Class.new(RuntimeError)
-
-        class Output < Capture
-          alias_method :raw_records, :records
-
-          def scope(*contexts, &block)
-            records = records(*contexts, &block)
-
-            Scope.build(records)
-          end
-
-          def recorded_once?(*contexts, &block)
-            record = one_record(*contexts, &block)
-
-            record ? true : false
-          end
-
-          def recorded?(*contexts, &block)
-            records = match_records(*contexts, &block)
-
-            records.any?
-          end
-
-          def one_record(*contexts, &block)
-            matching_records = match_records(*contexts, &block)
-
-            return if matching_records.empty?
-
-            unless matching_records.one?
-              raise MatchError, "More than one records match"
-            end
-
-            matching_records.shift
-          end
-
-          def records(*contexts, &block)
-            if contexts.empty? && block.nil?
-              return raw_records
-            end
-
-            match_records(*contexts, &block)
-          end
-
-          def match_records(*contexts, &block)
-            block ||= proc { true }
-
-            raw_records.select do |record|
-              context_iterator = record.context.to_enum
-
-              contexts_match = contexts.all? do |context|
-                until context_iterator.peek == context
-                  context_iterator.next
-                end
-                true
-
-              rescue StopIteration
-                false
-              end
-
-              contexts_match &&
-                block.(record.signal, *record.data, record.context)
-            end
-          end
-
-          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
-
-            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
-
-            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
-
-            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
-        end
-      end
-    end
-  end
-end

data/lib/test_bench/fixture/output.rb

@@ -1,57 +0,0 @@
-module TestBench
-  module Fixture
-    module Output
-      def self.signals
-        instance_methods(false)
-      end
-
-      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 comment(text)
-      end
-
-      def detail(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