hanami-minitest 3.0.0.rc1

data/lib/hanami/minitest/generators/part.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "hanami/cli/ruby_file_generator"
+
+module Hanami
+  module Minitest
+    module Generators
+      # @since 2.1.0
+      # @api private
+      class Part
+        # @since 2.1.0
+        # @api private
+        def initialize(fs:, inflector:)
+          @fs = fs
+          @inflector = inflector
+        end
+
+        # @since 2.1.0
+        # @api private
+        def call(app, slice, name)
+          camelized_app_name = inflector.camelize(app)
+          camelized_slice_name = slice ? inflector.camelize(slice) : nil
+          camelized_name = inflector.camelize(name)
+          underscored_name = inflector.underscore(name)
+
+          if slice
+            generate_for_slice(slice, camelized_app_name, camelized_slice_name, camelized_name, underscored_name)
+          else
+            generate_for_app(camelized_app_name, camelized_name, underscored_name)
+          end
+        end
+
+        private
+
+        # @since 2.1.0
+        # @api private
+        attr_reader :fs, :inflector
+
+        # @since 2.1.0
+        # @api private
+        def generate_for_slice(slice, camelized_app_name, camelized_slice_name, camelized_name, underscored_name)
+          generate_base_part_for_app(camelized_app_name)
+          generate_base_part_for_slice(slice, camelized_slice_name)
+
+          fs.write(
+            "test/slices/#{slice}/views/parts/#{underscored_name}_test.rb",
+            part_test_content(camelized_slice_name, camelized_name)
+          )
+        end
+
+        # @since 2.1.0
+        # @api private
+        def generate_for_app(camelized_app_name, camelized_name, underscored_name)
+          generate_base_part_for_app(camelized_app_name)
+
+          fs.write(
+            "test/views/parts/#{underscored_name}_test.rb",
+            part_test_content(camelized_app_name, camelized_name)
+          )
+        end
+
+        # @since 2.1.0
+        # @api private
+        def generate_base_part_for_app(camelized_app_name)
+          path = fs.join("test", "views", "part_test.rb")
+          return if fs.exist?(path)
+
+          fs.write(path, base_part_test_content(camelized_app_name))
+        end
+
+        # @since 2.1.0
+        # @api private
+        def generate_base_part_for_slice(slice, camelized_slice_name)
+          path = "test/slices/#{slice}/views/part_test.rb"
+          return if fs.exist?(path)
+
+          fs.write(path, base_part_test_content(camelized_slice_name))
+        end
+
+        # @since 2.1.0
+        # @api private
+        def base_part_test_content(camelized_namespace)
+          Hanami::CLI::RubyFileGenerator.class(
+            "PartTest",
+            parent_class_name: "Hanami::Minitest::Test",
+            header: ["# frozen_string_literal: true", "", 'require "test_helper"'],
+            body: [
+              "setup do",
+              "  @value = Object.new",
+              "  @subject = #{camelized_namespace}::Views::Part.new(value: @value)",
+              "end",
+              "",
+              'test "works" do',
+              "  assert_kind_of #{camelized_namespace}::Views::Part, @subject",
+              "end"
+            ]
+          )
+        end
+
+        # @since 2.1.0
+        # @api private
+        def part_test_content(camelized_namespace, camelized_name)
+          Hanami::CLI::RubyFileGenerator.class(
+            "#{camelized_name}Test",
+            parent_class_name: "Hanami::Minitest::Test",
+            header: ["# frozen_string_literal: true", "", 'require "test_helper"'],
+            body: [
+              "setup do",
+              "  @value = Object.new",
+              "  @subject = #{camelized_namespace}::Views::Parts::#{camelized_name}.new(value: @value)",
+              "end",
+              "",
+              'test "works" do',
+              "  assert_kind_of #{camelized_namespace}::Views::Parts::#{camelized_name}, @subject",
+              "end"
+            ]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/hanami/minitest/generators/slice.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "hanami/cli/ruby_file_generator"
+
+module Hanami
+  module Minitest
+    module Generators
+      # @since 2.0.0
+      # @api private
+      class Slice
+        # @since 2.0.0
+        # @api private
+        def initialize(fs:, inflector:)
+          @fs = fs
+          @inflector = inflector
+        end
+
+        # @since 2.0.0
+        # @api private
+        def call(slice)
+          camelized_slice_name = inflector.camelize(slice)
+
+          fs.write(
+            "test/slices/#{slice}/action_test.rb",
+            Hanami::CLI::RubyFileGenerator.class(
+              "ActionTest",
+              parent_class_name: "Hanami::Minitest::Test",
+              modules: [camelized_slice_name],
+              header: ["# frozen_string_literal: true", "", 'require "test_helper"'],
+              body: [
+                "test \"pending\" do",
+                "  skip \"Add tests for #{camelized_slice_name} actions\"",
+                "end"
+              ]
+            )
+          )
+
+          fs.write("test/slices/#{slice}/actions/.keep", "")
+        end
+
+        private
+
+        attr_reader :fs, :inflector
+      end
+    end
+  end
+end

data/lib/hanami/minitest/generators/templates/gemfile

@@ -0,0 +1,5 @@
+group :test do
+  # Web integration
+  gem "capybara"
+  gem "rack-test"
+end

data/lib/hanami/minitest/generators/templates/gemfile_db

@@ -0,0 +1,8 @@
+group :test do
+  # Database
+  gem "database_cleaner-sequel"
+
+  # Web integration
+  gem "capybara"
+  gem "rack-test"
+end

data/lib/hanami/minitest/generators/templates/gitignore

@@ -0,0 +1 @@
+.test_results/

data/lib/hanami/minitest/generators/templates/helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "pathname"
+TEST_ROOT = Pathname(__dir__).realpath.freeze
+
+ENV["HANAMI_ENV"] ||= "test"
+require "hanami/minitest"
+require "hanami/prepare"
+
+require_relative "support/minitest"
+TEST_ROOT.glob("support/**/*.rb").each { |f| require f }

data/lib/hanami/minitest/generators/templates/request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class RootTest < Hanami::Minitest::RequestTest
+  test "not found" do
+    get "/"
+
+    # Generate new action via:
+    #   `bundle exec hanami generate action home.index --url=/`
+    assert_equal 404, last_response.status
+  end
+end

data/lib/hanami/minitest/generators/templates/support_db.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "features"
+require_relative "db/cleaning"
+
+module TestSupport
+  module DB
+    def self.included(mod)
+      mod.include DB::Cleaning
+    end
+
+    # Add helper methods to be used by DB tests here.
+  end
+end
+
+class FeatureTest
+  include TestSupport::DB
+end

data/lib/hanami/minitest/generators/templates/support_db_cleaning.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "database_cleaner/sequel"
+
+module TestSupport
+  module DB
+    module Cleaning
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def db_cleaning_with_truncation!
+          @db_cleaning_with_truncation = true
+        end
+
+        def js! = db_cleaning_with_truncation!
+      end
+
+      def setup
+        # Clean all databases before the first test
+        Cleaning.once do
+          Cleaning.all_databases.each do |db|
+            DatabaseCleaner[:sequel, db: db].clean_with :truncation, except: ["schema_migrations"]
+          end
+        end
+
+        use_truncation = self.class.instance_variable_get(:@db_cleaning_with_truncation)
+        strategy = use_truncation ? :truncation : :transaction
+
+        Cleaning.all_databases.each do |db|
+          DatabaseCleaner[:sequel, db: db].strategy = strategy
+          DatabaseCleaner[:sequel, db: db].start
+        end
+
+        super
+      end
+
+      def teardown
+        Cleaning.all_databases.each do |db|
+          DatabaseCleaner[:sequel, db: db].clean
+        end
+
+        super
+      end
+
+      class << self
+        def once
+          @cleaned_once ||= false
+          return if @cleaned_once
+
+          yield
+
+          @cleaned_once = true
+        end
+
+        def all_databases
+          @all_databases ||= begin
+            slices = [Hanami.app] + Hanami.app.slices.with_nested
+
+            slices.each_with_object([]) { |slice, dbs|
+              next unless slice.key?("db.rom")
+
+              dbs.concat slice["db.rom"].gateways.values.map(&:connection)
+            }.uniq
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/minitest/generators/templates/support_features.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Hanami::Minitest::FeatureTest
+  # Add custom feature test helpers here.
+end

data/lib/hanami/minitest/generators/templates/support_minitest.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Hanami::Minitest::Test
+  # Add helper methods to be used by all tests here.
+end

data/lib/hanami/minitest/generators/templates/support_operations.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+
+class Hanami::Minitest::Test
+  # Provide `Success` and `Failure` for testing operation results.
+  include Dry::Monads[:result]
+end

data/lib/hanami/minitest/generators/templates/support_requests.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Hanami::Minitest::RequestTest
+  # Add custom request test helpers here.
+end

data/lib/hanami/minitest/rake_tasks.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+Hanami::CLI::RakeTasks.register_tasks do
+  require "rake/testtask"
+
+  Rake::TestTask.new(:test) do |t|
+    t.libs << "test"
+    t.libs << "lib"
+    t.test_files = FileList["test/**/*_test.rb"]
+  end
+
+  task default: :test
+end

data/lib/hanami/minitest/request_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "rack/test"
+require_relative "test"
+
+module Hanami
+  module Minitest
+    # Base test class for request tests in Hanami applications.
+    #
+    # Includes Rack::Test::Methods for making HTTP requests to the application.
+    #
+    # @since 2.0.0
+    # @api public
+    class RequestTest < Test
+      include Rack::Test::Methods
+
+      # Defines the app for Rack::Test requests.
+      #
+      # @return [Hanami::Application] the Hanami application
+      # @since 2.0.0
+      # @api public
+      def app
+        Hanami.app
+      end
+    end
+  end
+end

data/lib/hanami/minitest/test.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+
+module Hanami
+  module Minitest
+    # Base test class for Hanami applications.
+    #
+    # @since 2.0.0
+    # @api public
+    class Test < ::Minitest::Test
+      # Provides class-level block syntax for defining tests, setup, and teardown.
+      #
+      # @since 2.2.0
+      # @api public
+      module ClassMethods
+        # Defines a test method using a block.
+        #
+        # @param desc [String] the test description
+        # @yieldparam block the test body
+        #
+        # @example
+        #   test "it does something" do
+        #     assert true
+        #   end
+        #
+        # @since 2.2.0
+        # @api public
+        def test(desc = "anonymous", &block)
+          block ||= proc { skip "(no tests defined)" }
+          name = :"test_#{desc.gsub(/[^a-zA-Z0-9]+/, "_").gsub(/^_|_$/, "")}"
+          raise "#{name} is already defined in #{self}" if method_defined?(name)
+
+          define_method(name, &block)
+        end
+
+        # Defines a setup method using a block.
+        #
+        # The block runs after any superclass setup, ensuring the framework is
+        # fully initialized before your setup code runs.
+        #
+        # If you need control over when +super+ is called, define a regular
+        # +setup+ method instead:
+        #
+        #   def setup
+        #     @subject = MyClass.new
+        #     super
+        #   end
+        #
+        # @example
+        #   setup do
+        #     @subject = MyClass.new
+        #   end
+        #
+        # @since 2.2.0
+        # @api public
+        def setup(&block)
+          define_method(:setup) do
+            super()
+            instance_exec(&block)
+          end
+        end
+
+        # Defines a teardown method using a block.
+        #
+        # The block runs before any superclass teardown, ensuring your cleanup
+        # code runs before the framework tears down (e.g. before Capybara resets
+        # its session).
+        #
+        # If you need control over when +super+ is called, define a regular
+        # +teardown+ method instead:
+        #
+        #   def teardown
+        #     super
+        #     @subject.close
+        #   end
+        #
+        # @example
+        #   teardown do
+        #     @subject.close
+        #   end
+        #
+        # @since 2.2.0
+        # @api public
+        def teardown(&block)
+          define_method(:teardown) do
+            instance_exec(&block)
+            super()
+          end
+        end
+      end
+
+      extend ClassMethods
+    end
+  end
+end

data/lib/hanami/minitest/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Minitest
+    # The current hanami-minitest version.
+    #
+    # @api public
+    VERSION = "3.0.0.rc1"
+  end
+end

data/lib/hanami/minitest.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "hanami/cli"
+require "zeitwerk"
+
+# @see Hanami::Minitest
+# @since 2.0.0
+module Hanami
+  # Minitest and testing support for Hanami applications.
+  #
+  # @since 2.0.0
+  # @api private
+  module Minitest
+    # @api private
+    def self.gem_loader
+      @gem_loader ||= Zeitwerk::Loader.new.tap do |loader|
+        root = File.expand_path("..", __dir__)
+        loader.tag = "hanami-minitest"
+        loader.inflector = Zeitwerk::GemInflector.new("#{root}/hanami-minitest.rb")
+        loader.push_dir(root)
+        loader.ignore(
+          "#{root}/hanami-minitest.rb",
+          "#{root}/hanami/minitest/{rake_tasks,version}.rb",
+          "#{root}/hanami/minitest/generators/templates"
+        )
+      end
+    end
+
+    gem_loader.setup
+    require_relative "minitest/version"
+
+    if Hanami::CLI.within_hanami_app?
+      require_relative "minitest/commands"
+      require_relative "minitest/generators/action"
+      require_relative "minitest/generators/mailer"
+      require_relative "minitest/generators/operation"
+      require_relative "minitest/generators/part"
+      require_relative "minitest/generators/slice"
+
+      Hanami::CLI.before "install", Commands::Install
+      Hanami::CLI.after "generate slice", Commands::Generate::Slice
+
+      if Hanami.bundled?("dry-operation")
+        Hanami::CLI.after "generate operation", Commands::Generate::Operation
+      end
+
+      if Hanami.bundled?("hanami-controller")
+        Hanami::CLI.after "generate action", Commands::Generate::Action
+      end
+
+      if Hanami.bundled?("hanami-view")
+        Hanami::CLI.after "generate part", Commands::Generate::Part
+      end
+
+      if Hanami.bundled?("hanami-mailer")
+        Hanami::CLI.after "generate mailer", Commands::Generate::Mailer
+      end
+    end
+  end
+end

data/lib/hanami-minitest.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "hanami/minitest"
+
+# Load Rake tasks last, after hanami/minitest is fully loaded, to avoid circular requires.
+#
+# When you run `rake test` in a Hanami app, the Rakefile will first require all gems in the `:cli`
+# Bundler group, via Hanami CLI. If we required rake_tasks inside hanami/minitest.rb, that file
+# would still be mid-load when the Rake test runner loads the test files. Since each test file
+# requires test_helper.rb, which itself does `require "hanami/minitest"`, this would otherwise
+# lead to a circular require warning.
+require_relative "hanami/minitest/rake_tasks"