petitest 0.2.1 → 0.3.0

data/lib/petitest/subscribers/document_report_subscriber.rb

@@ -9,27 +9,27 @@ module Petitest
       include ::Petitest::SubscriberConcerns::TimeConcern
 
       # @note Override
-      def after_running_test_case(test_case)
+      def after_running_test(test)
         super
-        string = ::Petitest::Texts::TestCaseResultLineText.new(test_case: test_case).to_s
+        string = ::Petitest::Texts::TestResultLineText.new(test: test).to_s
         output.puts(string)
       end
 
       # @note Override
-      def after_running_test_cases(test_cases)
+      def after_running_test_plan(test_plan)
         super
-        string = ::Petitest::Texts::TestCasesResultText.new(
+        string = ::Petitest::Texts::TestsResultText.new(
           finished_at: finished_at,
           started_at: started_at,
-          test_cases: test_cases,
+          tests: test_plan.tests,
         ).to_s
         output.puts(string)
       end
 
       # @note Override
-      def before_running_test_group(test_group_class)
+      def before_running_test_group(test_group)
         super
-        string = "#{'  ' * test_group_class.nest_level}#{test_group_class.description}"
+        string = "#{'  ' * test_group.nest_level}#{test_group.description}"
         output.puts(string)
       end
     end

data/lib/petitest/subscribers/json_report_subscriber.rb

@@ -10,22 +10,22 @@ module Petitest
       include ::Petitest::SubscriberConcerns::TimeConcern
 
       # @note Override
-      def after_running_test_cases(test_cases)
+      def after_running_test_plan(test_plan)
         super
         data = {
-          test_cases: test_cases.map do |test_case|
+          tests: test_plan.tests.map do |test|
             {
-              backtrace: test_case.backtrace,
-              class_name: test_case.test_group_class.to_s,
-              error_class_name: test_case.error_class_name,
-              error_message: test_case.error_message,
-              failed: test_case.failed?,
-              finished_at: test_case.finished_at.iso8601(6),
-              method_line_number: test_case.test_method.line_number,
-              method_name: test_case.test_method.method_name,
-              path: test_case.test_method.path,
-              skipped: test_case.skipped?,
-              started_at: test_case.started_at.iso8601(6),
+              backtrace: test.runner.backtrace,
+              class_name: test.class.to_s,
+              error_class_name: test.runner.error_class_name,
+              error_message: test.runner.error_message,
+              failed: test.runner.failed?,
+              finished_at: test.runner.finished_at.iso8601(6),
+              method_line_number: test.runner.test_method.line_number,
+              method_name: test.runner.test_method.method_name,
+              path: test.runner.test_method.path,
+              skipped: test.runner.skipped?,
+              started_at: test.runner.started_at.iso8601(6),
             }
           end,
           times: {

data/lib/petitest/subscribers/progress_report_subscriber.rb

@@ -9,19 +9,19 @@ module Petitest
       include ::Petitest::SubscriberConcerns::TimeConcern
 
       # @note Override
-      def after_running_test_case(test_case)
+      def after_running_test(test)
         super
-        string = ::Petitest::Texts::TestCaseResultCharacterText.new(test_case: test_case).to_s
+        string = ::Petitest::Texts::TestResultCharacterText.new(test: test).to_s
         output.print(string)
       end
 
       # @note Override
-      def after_running_test_cases(test_cases)
+      def after_running_test_plan(test_plan)
         super
-        string = ::Petitest::Texts::TestCasesResultText.new(
+        string = ::Petitest::Texts::TestsResultText.new(
           finished_at: finished_at,
           started_at: started_at,
-          test_cases: test_cases,
+          tests: test_plan.tests,
         ).to_s
         output.puts(string)
       end

data/lib/petitest/test.rb

@@ -0,0 +1,142 @@
+module Petitest
+  class Test
+    TEST_METHOD_NAME_PREFIX = "test_"
+
+    class << self
+      attr_accessor :current_description
+
+      attr_writer :description
+
+      attr_writer :metadata
+
+      # @return [Array<Class>]
+      def children
+        @children ||= []
+      end
+
+      # @return [String]
+      def description
+        @description ||= name
+      end
+
+      # @return [Hash{Symbol => String}]
+      def description_by_method_name
+        @description_by_method_name ||= {}
+      end
+
+      # @return [Petitest::TestGroup]
+      def generate_test_group
+        ::Petitest::TestGroup.new(test_class: self)
+      end
+
+      # @return [String, nil]
+      def full_description
+        test_ancestors.reverse.map(&:description).join(" ")
+      end
+
+      # @note Override
+      def inherited(child)
+        super
+        children << child
+      end
+
+      # @return [Hash{Symbol => Object}]
+      def metadata
+        @metadata ||= {}
+      end
+
+      # @note Override
+      def method_added(method_name)
+        super
+        if current_description && check_if_test_method_name(method_name)
+          description_by_method_name[method_name] = current_description
+          clear_current_description
+        end
+      end
+
+      # @return [Array<Class>]
+      def test_ancestors
+        @test_ancestors ||= ancestors.each_with_object([]) do |klass, classes|
+          if klass == ::Petitest::Test
+            break classes
+          end
+          if klass.is_a?(::Class)
+            classes << klass
+          end
+        end
+      end
+
+      # @return [Array<Symbol>]
+      def test_method_names
+        public_instance_methods.select do |method_name|
+          check_if_test_method_name(method_name)
+        end
+      end
+
+      def undefine_test_methods
+        test_method_names.each do |method_name|
+          undef_method(method_name)
+        end
+      end
+
+      private
+
+      # @param method_name [Symbol]
+      # @return [Boolean]
+      def check_if_test_method_name(method_name)
+        method_name.to_s.start_with?(TEST_METHOD_NAME_PREFIX)
+      end
+
+      def clear_current_description
+        self.current_description = nil
+      end
+    end
+
+    # @param test_group [Petitest::TestGroup]
+    # @param test_method_name [Symbol]
+    def initialize(
+      test_group:,
+      test_method_name:
+    )
+      @test_group = test_group
+      @test_method_name = test_method_name
+    end
+
+    # @param actual_or_message [Object]
+    # @param message [String, nil]
+    def assert(actual_or_message = nil, message = nil, &block)
+      if block
+        message = actual_or_message
+        check(message || "Expected given block to return truthy", &block)
+      else
+        actual = actual_or_message
+        check(message || "Expected #{actual.inspect} to be truthy") do
+          actual
+        end
+      end
+    end
+
+    # @param message [String, nil]
+    def skip(message = nil)
+      raise ::Petitest::AssertionSkipError.new(message)
+    end
+
+    # @return [Petitest::TestRunner]
+    def runner
+      @runner ||= Petitest::TestRunner.new(
+        test: self,
+        test_group: @test_group,
+        test_method_name: @test_method_name,
+      )
+    end
+
+    private
+
+    # @param message [String, nil]
+    def check(message, &block)
+      unless block.call
+        raise ::Petitest::AssertionFailureError.new(message)
+      end
+    end
+  end
+end

data/lib/petitest/test_group.rb

@@ -1,140 +1,50 @@
 module Petitest
   class TestGroup
-    TEST_METHOD_NAME_PREFIX = "test_"
+    # @return [Class]
+    attr_reader :test_class
 
-    class << self
-      attr_writer :description
-
-      attr_writer :metadata
-
-      attr_writer :nest_level
-
-      # @return [Array<Class>]
-      def children
-        @children ||= []
-      end
-
-      # @return [Array<Class>]
-      def descendants
-        children.flat_map(&:children)
-      end
-
-      # @return [String]
-      def description
-        @description ||= name
-      end
-
-      # @return [String, nil]
-      def full_description
-        descriptions = concrete_test_group_ancestors.reverse.map(&:description)
-        unless descriptions.empty?
-          descriptions.join(" ")
-        end
-      end
-
-      # @note Override
-      def inherited(child)
-        super
-        children << child
-      end
-
-      # @return [Hash{Symbol => Object}]
-      def metadata
-        @metadata ||= {}
-      end
-
-      # @return [Integer]
-      def nest_level
-        @nest_level ||= 0
-      end
-
-      # @param description [String]
-      # @param metadata [Hash{Symbol => Object}]
-      def sub_test_group(description, metadata = {}, &block)
-        child = ::Class.new(self)
-        child.nest_level = nest_level + 1
-        child.description = description
-        child.metadata = self.metadata.merge(metadata)
-        child.undefine_test_methods
-        child.class_eval(&block)
-        child
-      end
-
-      # @return [Array<Petit::TestCase>]
-      def test_cases
-        @test_cases ||= test_methods.map do |test_method|
-          ::Petitest::TestCase.new(
-            test_group_class: self,
-            test_method: test_method,
-          )
-        end
-      end
-
-      # @return [Array<Petit::TestCase>]
-      def test_cases_and_children_test_cases
-        test_cases + children.flat_map(&:test_cases_and_children_test_cases)
-      end
-
-      # @return [Array<String>]
-      def test_method_names
-        public_instance_methods.map(&:to_s).select do |method_name|
-          method_name.start_with?(TEST_METHOD_NAME_PREFIX)
-        end
-      end
+    # @param test_class [Class]
+    def initialize(test_class:)
+      @test_class ||= test_class
+    end
 
-      # @return [Array<Petitest::TestMethod>]
-      def test_methods
-        test_method_names.map do |method_name|
-          unbound_method = public_instance_method(method_name)
-          ::Petitest::TestMethod.new(
-            line_number: unbound_method.source_location[1],
-            method_name: method_name.to_s,
-            path: unbound_method.source_location[0],
-          )
-        end
-      end
+    # @return [String]
+    def description
+      test_class.description
+    end
 
-      def undefine_test_methods
-        test_method_names.each do |method_name|
-          undef_method(method_name)
-        end
-      end
+    # @return [String]
+    def full_description
+      test_class.test_ancestors.reverse.map(&:description).join(" ")
+    end
 
-      private
+    # @return [Hash{Symbol => Object}]
+    def metadata
+      test_class.metadata
+    end
 
-      # @return [Array<Class>]
-      def concrete_test_group_ancestors
-        ancestors.each_with_object([]) do |klass, classes|
-          if klass == ::Petitest::TestGroup
-            break classes
-          end
-          if klass.is_a?(::Class)
-            classes << klass
-          end
-        end
-      end
+    # @return [Integer]
+    def nest_level
+      test_class.test_ancestors.length - 1
     end
 
-    # @param actual_or_message [Object]
-    # @param message [String, nil]
-    def assert(actual_or_message = nil, message = nil, &block)
-      if block
-        message = actual_or_message
-        check(message || "Expected given block to return truthy", &block)
-      else
-        actual = actual_or_message
-        check(message || "Expected #{actual.inspect} to be truthy") do
-          actual
-        end
-      end
+    # @return [Array<Petitest::Test>]
+    def self_and_descendant_tests
+      tests + sub_test_groups.flat_map(&:self_and_descendant_tests)
     end
 
-    private
+    # @return [Array<Petitest::TestGroup>]
+    def sub_test_groups
+      @sub_test_groups ||= test_class.children.map(&:generate_test_group)
+    end
 
-    # @param message [String, nil]
-    def check(message, &block)
-      unless block.call
-        raise ::Petitest::AssertionFailureError.new(message)
+    # @return [Array<Petitest::Test>]
+    def tests
+      @tests ||= test_class.test_method_names.map do |test_method_name|
+        test_class.new(
+          test_group: self,
+          test_method_name: test_method_name,
+        )
       end
     end
   end

data/lib/petitest/test_plan.rb

@@ -0,0 +1,102 @@
+module Petitest
+  class TestPlan
+    # @return [Array<Class>]
+    attr_reader :test_classes
+
+    # @param test_classes [Array<Class>]
+    def initialize(test_classes:)
+      @test_classes = test_classes
+    end
+
+    # @return [Boolean]
+    def passed?
+      tests.map(&:runner).all? do |runner|
+        runner.passed? || runner.skipped?
+      end
+    end
+
+    def run
+      before_running_test_plan
+      test_groups.each do |test_group|
+        run_test_group(test_group)
+      end
+      after_running_test_plan
+    end
+
+    # @return [Array<Petitest::TestGroup>]
+    def test_groups
+      @test_groups ||= test_classes.map(&:generate_test_group)
+    end
+
+    # @return [Array<Petitest::Test>]
+    def tests
+      test_groups.flat_map(&:self_and_descendant_tests)
+    end
+
+    private
+
+    # @param test [Petitest::Test]
+    def after_running_test(test)
+      subscribers.each do |subscriber|
+        subscriber.after_running_test(test)
+      end
+    end
+
+    # @param test_group [Petitest::TestGroup]
+    def after_running_test_group(test_group)
+      subscribers.each do |subscriber|
+        subscriber.after_running_test_group(test_group)
+      end
+    end
+
+    def after_running_test_plan
+      subscribers.each do |subscriber|
+        subscriber.after_running_test_plan(self)
+      end
+    end
+
+    # @param test [Petitest::Test]
+    def before_running_test(test)
+      subscribers.each do |subscriber|
+        subscriber.before_running_test(test)
+      end
+    end
+
+    # @param test_group [Petitest::TestGroup]
+    def before_running_test_group(test_group)
+      subscribers.each do |subscriber|
+        subscriber.before_running_test_group(test_group)
+      end
+    end
+
+    def before_running_test_plan
+      subscribers.each do |subscriber|
+        subscriber.before_running_test_plan(self)
+      end
+    end
+
+    # @param test [Petitest::Test]
+    def run_test(test)
+      before_running_test(test)
+      test.runner.run
+      after_running_test(test)
+    end
+
+    # @param test_group [Petitest::TestGroup]
+    def run_test_group(test_group)
+      before_running_test_group(test_group)
+      test_group.tests.each do |test|
+        run_test(test)
+      end
+      test_group.sub_test_groups.each do |sub_test_group|
+        run_test_group(sub_test_group)
+      end
+      after_running_test_group(test_group)
+    end
+
+    # @return [Array<Petitest::Subscribers::BaseSubscriber>]
+    def subscribers
+      ::Petitest.configuration.subscribers
+    end
+  end
+end