torikago 0.0.1 → 0.1.0

data/test/torikago/engine_container.rb

@@ -10,42 +10,426 @@ class TorikagoEngineContainerTest < Minitest::Test
     Object.send(:remove_const, :SharedDependency) if Object.const_defined?(:SharedDependency, false)
     Object.send(:remove_const, :SetupProbe) if Object.const_defined?(:SetupProbe, false)
     Object.send(:remove_const, :VersionedFormatter) if Object.const_defined?(:VersionedFormatter, false)
+    Object.send(:remove_const, :WidgetsController) if Object.const_defined?(:WidgetsController, false)
   end
 
-  def test_call_loads_the_public_api_class_and_executes_call
+  def test_invoke_loads_the_public_api_class_and_executes_call
     with_module_root do |module_root|
       container = Torikago::EngineContainer.new(name: :foo, module_root: module_root)
 
-      result = container.call("Foo::ListProductsQuery")
+      result = container.invoke("Foo::ListProductsQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
 
       assert_equal ["coffee-beans", "drip-bag"], result
     end
   end
 
-  def test_call_reuses_loaded_runtime_files_across_calls
+  def test_invoke_reuses_loaded_runtime_files_across_calls
     with_module_root do |module_root|
       container = Torikago::EngineContainer.new(name: :foo, module_root: module_root)
 
-      first = container.call("Foo::ListProductsQuery")
-      second = container.call("Foo::ListProductsQuery")
+      first = container.invoke("Foo::ListProductsQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+      second = container.invoke("Foo::ListProductsQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
 
       assert_equal ["coffee-beans", "drip-bag"], first
       assert_equal ["coffee-beans", "drip-bag"], second
     end
   end
 
-  def test_call_sets_the_current_box_during_execution
+  def test_invoke_sets_the_current_box_during_execution
     with_module_root do |module_root|
       container = Torikago::EngineContainer.new(name: :foo, module_root: module_root)
 
-      result = container.call("Foo::CurrentBoxQuery")
+      result = container.invoke("Foo::CurrentBoxQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
 
       assert_equal :foo, result
       assert_nil Torikago::CurrentExecution.current_box
     end
   end
 
-  def test_call_uses_a_configured_entrypoint_directory_when_present
+  def test_invoke_shares_root_constants_and_runtime_gateway_with_a_ruby_box
+    Dir.mktmpdir("torikago-root-access") do |application_root|
+      module_root = File.join(application_root, "modules/foo")
+      package_api_dir = File.join(module_root, "app/package_api/foo")
+      FileUtils.mkdir_p(package_api_dir)
+
+      root_constant_file = File.join(application_root, "root_constants.rb")
+      File.write(
+        root_constant_file,
+        <<~RUBY
+          class RootOrder
+          end
+
+          class RootCustomerQuery
+            def self.call
+              "root customer"
+            end
+          end
+        RUBY
+      )
+      lazy_constant_file = File.join(application_root, "root_lazy_query.rb")
+      File.write(
+        lazy_constant_file,
+        <<~RUBY
+          class RootLazyQuery
+            def self.call
+              "lazy root"
+            end
+          end
+        RUBY
+      )
+      File.write(
+        File.join(package_api_dir, "root_access_query.rb"),
+        <<~RUBY
+          class Foo::RootAccessQuery < ::RootOrder
+            def call
+              [
+                ::RootCustomerQuery.call,
+                ::RootLazyQuery.call,
+                self.class.superclass.object_id,
+                Torikago.object_id,
+                Torikago::Gateway.object_id,
+                Torikago::DependencyError.object_id,
+                Torikago::Gateway.invoke("Bar::Ping", :call)
+              ]
+            end
+          end
+        RUBY
+      )
+
+      assert_ruby_box_child_process(
+        <<~RUBY,
+          $LOAD_PATH.unshift(ARGV.fetch(0))
+          module_root = ARGV.fetch(1)
+          root_constant_file = ARGV.fetch(2)
+          lazy_constant_file = ARGV.fetch(3)
+
+          require "torikago"
+          load root_constant_file
+          autoload :RootLazyQuery, lazy_constant_file
+          gateway_probe = Object.new
+          gateway_probe.define_singleton_method(:invoke) { |class_name, method_name| [class_name, method_name] }
+          Torikago.instance_variable_set(:@gateway, gateway_probe)
+
+          container = Torikago::EngineContainer.new(
+            name: :foo,
+            module_root: module_root,
+            registered_roots: [module_root]
+          )
+
+          result = container.invoke("Foo::RootAccessQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+          expected_shared_values = [
+            "root customer",
+            "lazy root",
+            RootOrder.object_id,
+            Torikago::Gateway.object_id,
+            Torikago::DependencyError.object_id,
+            ["Bar::Ping", :call]
+          ]
+          shared_values = result.values_at(0, 1, 2, 4, 5, 6)
+          raise "unexpected result: \#{result.inspect}" unless shared_values == expected_shared_values
+          raise "host Torikago namespace leaked into module Box" if result.fetch(3) == Torikago.object_id
+
+          Object.send(:remove_const, :RootCustomerQuery)
+          class RootCustomerQuery
+            def self.call
+              "reloaded root customer"
+            end
+          end
+          reloaded_result = container.invoke("Foo::RootAccessQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+          raise "stale root constant: \#{reloaded_result.inspect}" unless reloaded_result.first == "reloaded root customer"
+
+          puts "ok"
+        RUBY
+        module_root,
+        root_constant_file,
+        lazy_constant_file
+      )
+    end
+  end
+
+  def test_invoke_prefers_module_local_constants_over_root_constants
+    Dir.mktmpdir("torikago-root-access") do |application_root|
+      module_root = File.join(application_root, "modules/foo")
+      package_api_dir = File.join(module_root, "app/package_api/foo")
+      FileUtils.mkdir_p(package_api_dir)
+
+      root_constant_file = File.join(application_root, "root_constant.rb")
+      File.write(root_constant_file, "RootPriority = \"root\"\n")
+      File.write(
+        File.join(package_api_dir, "priority_query.rb"),
+        <<~RUBY
+          RootPriority = "module"
+
+          class Foo::PriorityQuery
+            def call
+              RootPriority
+            end
+          end
+        RUBY
+      )
+
+      assert_ruby_box_child_process(
+        <<~RUBY,
+          $LOAD_PATH.unshift(ARGV.fetch(0))
+          module_root = ARGV.fetch(1)
+          root_constant_file = ARGV.fetch(2)
+
+          require "torikago"
+          load root_constant_file
+
+          container = Torikago::EngineContainer.new(
+            name: :foo,
+            module_root: module_root,
+            registered_roots: [module_root]
+          )
+
+          result = container.invoke("Foo::PriorityQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+          raise "unexpected result: \#{result.inspect}" unless result == "module"
+
+          puts "ok"
+        RUBY
+        module_root,
+        root_constant_file
+      )
+    end
+  end
+
+  def test_invoke_does_not_share_constants_owned_by_a_registered_root
+    Dir.mktmpdir("torikago-root-access") do |application_root|
+      foo_root = File.join(application_root, "packs/foo")
+      bar_root = File.join(application_root, "components/bar")
+      package_api_dir = File.join(foo_root, "app/package_api/foo")
+      FileUtils.mkdir_p(package_api_dir)
+      FileUtils.mkdir_p(bar_root)
+
+      registered_constant_file = File.join(bar_root, "bar_internal.rb")
+      File.write(registered_constant_file, "class BarInternal; end\n")
+      File.write(
+        File.join(package_api_dir, "forbidden_root_query.rb"),
+        <<~RUBY
+          class Foo::ForbiddenRootQuery
+            def call
+              ::BarInternal
+            end
+          end
+        RUBY
+      )
+
+      assert_ruby_box_child_process(
+        <<~RUBY,
+          $LOAD_PATH.unshift(ARGV.fetch(0))
+          foo_root = ARGV.fetch(1)
+          bar_root = ARGV.fetch(2)
+          registered_constant_file = ARGV.fetch(3)
+
+          require "torikago"
+          load registered_constant_file
+
+          container = Torikago::EngineContainer.new(
+            name: :foo,
+            module_root: foo_root,
+            registered_roots: [foo_root, bar_root]
+          )
+
+          begin
+            container.invoke("Foo::ForbiddenRootQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+            raise "registered constant was unexpectedly shared"
+          rescue NameError => error
+            raise unless error.message.include?("BarInternal")
+          end
+
+          puts "ok"
+        RUBY
+        foo_root,
+        bar_root,
+        registered_constant_file
+      )
+    end
+  end
+
+  def test_invoke_does_not_resolve_a_qualified_module_constant_from_root
+    Dir.mktmpdir("torikago-root-access") do |application_root|
+      module_root = File.join(application_root, "modules/foo")
+      package_api_dir = File.join(module_root, "app/package_api/foo")
+      FileUtils.mkdir_p(package_api_dir)
+
+      root_constant_file = File.join(application_root, "order.rb")
+      File.write(root_constant_file, "class Order; end\n")
+      File.write(
+        File.join(package_api_dir, "qualified_constant_query.rb"),
+        <<~RUBY
+          class Foo::QualifiedConstantQuery
+            def call
+              Foo::Order
+            end
+          end
+        RUBY
+      )
+
+      assert_ruby_box_child_process(
+        <<~RUBY,
+          $LOAD_PATH.unshift(ARGV.fetch(0))
+          module_root = ARGV.fetch(1)
+          root_constant_file = ARGV.fetch(2)
+
+          require "torikago"
+          load root_constant_file
+
+          container = Torikago::EngineContainer.new(
+            name: :foo,
+            module_root: module_root,
+            registered_roots: [module_root]
+          )
+
+          begin
+            container.invoke("Foo::QualifiedConstantQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+            raise "Foo::Order unexpectedly resolved to ::Order"
+          rescue NameError => error
+            raise unless error.message.include?("Foo::Order")
+          end
+
+          puts "ok"
+        RUBY
+        module_root,
+        root_constant_file
+      )
+    end
+  end
+
+  def test_invoke_does_not_share_a_root_namespace_with_a_registered_descendant
+    Dir.mktmpdir("torikago-root-access") do |application_root|
+      foo_root = File.join(application_root, "modules/foo")
+      bar_root = File.join(application_root, "modules/bar")
+      package_api_dir = File.join(foo_root, "app/package_api/foo")
+      FileUtils.mkdir_p(package_api_dir)
+      FileUtils.mkdir_p(bar_root)
+
+      root_namespace_file = File.join(application_root, "shared_namespace.rb")
+      registered_constant_file = File.join(bar_root, "bar_internal.rb")
+      File.write(root_namespace_file, "module SharedNamespace; end\n")
+      File.write(registered_constant_file, "class SharedNamespace::BarInternal; end\n")
+      File.write(
+        File.join(package_api_dir, "shared_namespace_query.rb"),
+        <<~RUBY
+          class Foo::SharedNamespaceQuery
+            def call
+              ::SharedNamespace::BarInternal
+            end
+          end
+        RUBY
+      )
+
+      assert_ruby_box_child_process(
+        <<~RUBY,
+          $LOAD_PATH.unshift(ARGV.fetch(0))
+          foo_root = ARGV.fetch(1)
+          bar_root = ARGV.fetch(2)
+          root_namespace_file = ARGV.fetch(3)
+          registered_constant_file = ARGV.fetch(4)
+
+          require "torikago"
+          load root_namespace_file
+          load registered_constant_file
+
+          container = Torikago::EngineContainer.new(
+            name: :foo,
+            module_root: foo_root,
+            registered_roots: [foo_root, bar_root]
+          )
+
+          begin
+            container.invoke("Foo::SharedNamespaceQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+            raise "registered descendant was unexpectedly shared"
+          rescue NameError => error
+            raise unless error.message.include?("SharedNamespace")
+          end
+
+          puts "ok"
+        RUBY
+        foo_root,
+        bar_root,
+        root_namespace_file,
+        registered_constant_file
+      )
+    end
+  end
+
+  def test_invoke_does_not_strip_bundler_env_during_public_api_execution
+    with_module_root do |module_root|
+      File.write(
+        File.join(module_root, "app/package_api/foo/env_query.rb"),
+        <<~RUBY
+          class Foo::EnvQuery
+            def call
+              [ENV["RUBYOPT"], ENV["BUNDLER_SETUP"]]
+            end
+          end
+        RUBY
+      )
+
+      old_rubyopt = ENV["RUBYOPT"]
+      old_bundler_setup = ENV["BUNDLER_SETUP"]
+      ENV["RUBYOPT"] = "-rbundler/setup -w"
+      ENV["BUNDLER_SETUP"] = "true"
+
+      container = Torikago::EngineContainer.new(
+        name: :foo,
+        module_root: module_root,
+        box_factory: -> { FakeBox.new }
+      )
+
+      assert_equal ["-rbundler/setup -w", "true"], container.invoke("Foo::EnvQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+    ensure
+      restore_env("RUBYOPT", old_rubyopt)
+      restore_env("BUNDLER_SETUP", old_bundler_setup)
+    end
+  end
+
+  def test_bundler_env_stripping_is_serialized_across_containers
+    first_container = Torikago::EngineContainer.new(name: :foo, module_root: Dir.pwd)
+    second_container = Torikago::EngineContainer.new(name: :bar, module_root: Dir.pwd)
+    first_entered = Queue.new
+    release_first = Queue.new
+    second_ready = Queue.new
+    second_entered = Queue.new
+
+    old_rubyopt = ENV["RUBYOPT"]
+    old_bundler_setup = ENV["BUNDLER_SETUP"]
+    ENV["RUBYOPT"] = "-rbundler/setup"
+    ENV["BUNDLER_SETUP"] = "true"
+
+    first_thread = Thread.new do
+      first_container.send(:without_bundler_setup_env) do
+        first_entered << true
+        release_first.pop
+      end
+    end
+    first_entered.pop
+
+    second_thread = Thread.new do
+      second_ready << true
+      second_container.send(:without_bundler_setup_env) do
+        second_entered << true
+      end
+    end
+    second_ready.pop
+
+    sleep 0.05
+    assert_predicate second_entered, :empty?
+
+    release_first << true
+    first_thread.join
+    second_thread.join
+
+    refute_predicate second_entered, :empty?
+  ensure
+    first_thread&.kill if first_thread&.alive?
+    second_thread&.kill if second_thread&.alive?
+    restore_env("RUBYOPT", old_rubyopt)
+    restore_env("BUNDLER_SETUP", old_bundler_setup)
+  end
+
+  def test_invoke_uses_a_configured_entrypoint_directory_when_present
     with_custom_entrypoint_module_root do |module_root|
       container = Torikago::EngineContainer.new(
         name: :foo,
@@ -53,13 +437,13 @@ class TorikagoEngineContainerTest < Minitest::Test
         entrypoint: "components/public_api"
       )
 
-      result = container.call("Foo::CustomEntryPointQuery")
+      result = container.invoke("Foo::CustomEntryPointQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
 
       assert_equal "custom entrypoint", result
     end
   end
 
-  def test_call_does_not_load_parent_files_when_configured_entrypoint_directory_is_missing
+  def test_invoke_does_not_load_parent_files_when_configured_entrypoint_directory_is_missing
     Dir.mktmpdir("torikago-engine-container") do |module_root|
       FileUtils.mkdir_p(File.join(module_root, "app/controllers/foo"))
       File.write(
@@ -76,14 +460,213 @@ class TorikagoEngineContainerTest < Minitest::Test
       )
 
       error = assert_raises(NameError) do
-        container.call("Foo::MissingQuery")
+        container.invoke("Foo::MissingQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
       end
 
       assert_match(/MissingQuery/, error.message)
     end
   end
 
-  def test_call_prepends_explicit_gemfile_require_paths_before_loading_runtime
+  def test_invoke_loads_plain_lib_entrypoint_by_default
+    with_module_root do |module_root|
+      lib_dir = File.join(module_root, "lib")
+      FileUtils.mkdir_p(lib_dir)
+      File.write(
+        File.join(lib_dir, "foo.rb"),
+        <<~RUBY
+          module Foo
+            PLAIN_LIB_ENTRYPOINT = "loaded"
+          end
+        RUBY
+      )
+      File.write(
+        File.join(module_root, "app/package_api/foo/plain_lib_entrypoint_query.rb"),
+        <<~RUBY
+          class Foo::PlainLibEntrypointQuery
+            def call
+              Foo::PLAIN_LIB_ENTRYPOINT
+            end
+          end
+        RUBY
+      )
+
+      container = Torikago::EngineContainer.new(name: :foo, module_root: module_root)
+
+      assert_equal "loaded", container.invoke("Foo::PlainLibEntrypointQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+    end
+  end
+
+  def test_invoke_loads_the_module_lib_entrypoint_when_rails_engine_is_enabled
+    with_module_root do |module_root|
+      lib_dir = File.join(module_root, "lib")
+      FileUtils.mkdir_p(File.join(lib_dir, "foo"))
+      File.write(
+        File.join(lib_dir, "foo.rb"),
+        <<~RUBY
+          module Foo
+            RAILS_ENGINE_ENTRYPOINT = "loaded in module runtime"
+          end
+        RUBY
+      )
+      File.write(
+        File.join(lib_dir, "foo/support.rb"),
+        <<~RUBY
+          module Foo
+            SUPPORT_VALUE = "ordinary lib file loaded"
+          end
+        RUBY
+      )
+      File.write(
+        File.join(module_root, "app/package_api/foo/rails_engine_support_query.rb"),
+        <<~RUBY
+          class Foo::RailsEngineSupportQuery
+            def call
+              [Foo::RAILS_ENGINE_ENTRYPOINT, Foo::SUPPORT_VALUE]
+            end
+          end
+        RUBY
+      )
+
+      container = Torikago::EngineContainer.new(
+        name: :foo,
+        module_root: module_root,
+        rails_engine: true
+      )
+
+      assert_equal(
+        ["loaded in module runtime", "ordinary lib file loaded"],
+        container.invoke("Foo::RailsEngineSupportQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+      )
+    end
+  end
+
+  def test_call_loads_and_dispatches_to_a_top_level_rails_runtime_controller
+    Dir.mktmpdir("torikago-engine-container") do |module_root|
+      FileUtils.mkdir_p(File.join(module_root, "lib"))
+      FileUtils.mkdir_p(File.join(module_root, "app/controllers"))
+      FileUtils.mkdir_p(File.join(module_root, "config"))
+      File.write(
+        File.join(module_root, "lib/foo.rb"),
+        <<~RUBY
+          module Foo
+            class Routes
+              def recognize_path(path, method:)
+                raise "unexpected path" unless path == "/widgets/7"
+                raise "unexpected method" unless method == :get
+
+                { "controller" => "widgets", "action" => "show", "id" => "7" }
+              end
+            end
+
+            class Engine
+              def self.routes
+                @routes ||= Routes.new
+              end
+            end
+          end
+        RUBY
+      )
+      File.write(
+        File.join(module_root, "app/controllers/widgets_controller.rb"),
+        <<~RUBY
+          class WidgetsController
+            def self.action(action_name)
+              lambda do |env|
+                params = env.fetch("action_dispatch.request.path_parameters")
+                [
+                  200,
+                  { "content-type" => "text/plain" },
+                  ["\#{action_name}:\#{params.fetch(:id)}:\#{Torikago::CurrentExecution.current_box}"]
+                ]
+              end
+            end
+          end
+        RUBY
+      )
+
+      container = Torikago::EngineContainer.new(
+        name: :foo,
+        module_root: module_root,
+        rails_engine: true,
+        box_factory: -> { FakeBox.new }
+      )
+
+      response = container.call("PATH_INFO" => "/widgets/7", "REQUEST_METHOD" => "GET")
+
+      assert_equal [200, { "content-type" => "text/plain" }, ["show:7:foo"]], response
+      assert_nil Torikago::CurrentExecution.current_box
+    end
+  end
+
+  def test_dispatch_controller_loads_a_top_level_controller_without_a_rails_engine
+    with_module_root do |module_root|
+      controller_dir = File.join(module_root, "app/controllers")
+      FileUtils.mkdir_p(controller_dir)
+      File.write(
+        File.join(controller_dir, "widgets_controller.rb"),
+        <<~RUBY
+          class WidgetsController
+            def self.action(action_name)
+              lambda do |env|
+                params = env.fetch("action_dispatch.request.path_parameters")
+                [
+                  200,
+                  { "content-type" => "text/plain" },
+                  ["\#{action_name}:\#{params.fetch(:id)}:\#{Torikago::CurrentExecution.current_box}"]
+                ]
+              end
+            end
+          end
+        RUBY
+      )
+
+      container = Torikago::EngineContainer.new(
+        name: :foo,
+        module_root: module_root,
+        box_factory: -> { FakeBox.new }
+      )
+
+      # A prior Package API invocation must not prevent the later controller
+      # runtime from loading.
+      assert_equal(
+        ["coffee-beans", "drip-bag"],
+        container.invoke(
+          "Foo::ListProductsQuery",
+          :call,
+          constructor_args: [],
+          constructor_kwargs: {},
+          method_args: [],
+          method_kwargs: {}
+        )
+      )
+
+      response = container.dispatch_controller(
+        {
+          "PATH_INFO" => "/widgets/7",
+          "action_dispatch.request.path_parameters" => { id: "7" }
+        },
+        controller_name: "WidgetsController",
+        action_name: :show
+      )
+
+      assert_equal [200, { "content-type" => "text/plain" }, ["show:7:foo"]], response
+      assert_nil Torikago::CurrentExecution.current_box
+    end
+  end
+
+  def test_call_rejects_modules_without_a_rails_engine
+    with_module_root do |module_root|
+      container = Torikago::EngineContainer.new(name: :foo, module_root: module_root)
+
+      error = assert_raises(ArgumentError) do
+        container.call("PATH_INFO" => "/", "REQUEST_METHOD" => "GET")
+      end
+
+      assert_match(/rails_engine: true/, error.message)
+    end
+  end
+
+  def test_invoke_prepends_explicit_gemfile_require_paths_before_loading_runtime
     with_module_root do |module_root|
       dependency_lib = File.join(module_root, "vendor/example-gem-1.2.3/lib")
       FileUtils.mkdir_p(dependency_lib)
@@ -131,7 +714,7 @@ class TorikagoEngineContainerTest < Minitest::Test
             end
           )
 
-          raise "unexpected result" unless container.call("Foo::DependencyVersionQuery") == "module-local"
+          raise "unexpected result" unless container.invoke("Foo::DependencyVersionQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {}) == "module-local"
 
           puts "ok"
         RUBY
@@ -141,7 +724,7 @@ class TorikagoEngineContainerTest < Minitest::Test
     end
   end
 
-  def test_call_resolves_path_gem_require_paths_inside_ruby_box
+  def test_invoke_resolves_path_gem_require_paths_inside_ruby_box
     Dir.mktmpdir("torikago-engine-container") do |module_root|
       dependency_lib = File.join(module_root, "vendor/example-gem-1.0.0/lib")
       FileUtils.mkdir_p(dependency_lib)
@@ -203,7 +786,7 @@ class TorikagoEngineContainerTest < Minitest::Test
             gemfile: "Gemfile"
           )
 
-          raise "unexpected result" unless container.call("Foo::DependencyVersionQuery") == "module-local"
+          raise "unexpected result" unless container.invoke("Foo::DependencyVersionQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {}) == "module-local"
 
           puts "ok"
         RUBY
@@ -212,7 +795,7 @@ class TorikagoEngineContainerTest < Minitest::Test
     end
   end
 
-  def test_call_resolves_path_gem_require_paths_from_the_module_gemfile
+  def test_invoke_resolves_path_gem_require_paths_from_the_module_gemfile
     Dir.mktmpdir("torikago-engine-container") do |module_root|
       dependency_root = File.join(module_root, "vendor/versioned_formatter")
       dependency_lib = File.join(dependency_root, "lib")
@@ -275,7 +858,7 @@ class TorikagoEngineContainerTest < Minitest::Test
             gemfile: "Gemfile"
           )
 
-          raise "unexpected result" unless container.call("Foo::GemfileDependencyQuery") == "1.0.0"
+          raise "unexpected result" unless container.invoke("Foo::GemfileDependencyQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {}) == "1.0.0"
 
           puts "ok"
         RUBY
@@ -284,7 +867,7 @@ class TorikagoEngineContainerTest < Minitest::Test
     end
   end
 
-  def test_call_resolves_exact_installed_gem_require_paths_after_a_different_version_is_active
+  def test_invoke_resolves_exact_installed_gem_require_paths_after_a_different_version_is_active
     skip("requires rake 13.3.1 and 13.4.2") unless installed_gem?("rake", "= 13.3.1") && installed_gem?("rake", "= 13.4.2")
 
     Dir.mktmpdir("torikago-engine-container") do |module_root|
@@ -314,7 +897,7 @@ class TorikagoEngineContainerTest < Minitest::Test
     end
   end
 
-  def test_call_reports_missing_installed_gemfile_dependencies_clearly
+  def test_invoke_reports_missing_installed_gemfile_dependencies_clearly
     with_module_root do |module_root|
       File.write(
         File.join(module_root, "Gemfile"),
@@ -332,7 +915,7 @@ class TorikagoEngineContainerTest < Minitest::Test
       )
 
       error = assert_raises(Torikago::GemfileOverrideError) do
-        container.call("Foo::ListProductsQuery")
+        container.invoke("Foo::ListProductsQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
       end
 
       assert_match(/example-gem/, error.message)
@@ -340,7 +923,7 @@ class TorikagoEngineContainerTest < Minitest::Test
     end
   end
 
-  def test_call_loads_configured_setup_before_public_api
+  def test_invoke_loads_configured_setup_before_public_api
     with_module_root do |module_root|
       setup_dir = File.join(module_root, "config")
       FileUtils.mkdir_p(setup_dir)
@@ -370,11 +953,11 @@ class TorikagoEngineContainerTest < Minitest::Test
         setup: "config/box_setup.rb"
       )
 
-      assert_equal "patched", container.call("Foo::SetupAwareQuery")
+      assert_equal "patched", container.invoke("Foo::SetupAwareQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
     end
   end
 
-  def test_call_loads_setup_only_once
+  def test_invoke_loads_setup_only_once
     with_module_root do |module_root|
       setup_dir = File.join(module_root, "config")
       FileUtils.mkdir_p(setup_dir)
@@ -404,12 +987,12 @@ class TorikagoEngineContainerTest < Minitest::Test
         setup: "config/box_setup.rb"
       )
 
-      assert_equal 1, container.call("Foo::SetupCountQuery")
-      assert_equal 1, container.call("Foo::SetupCountQuery")
+      assert_equal 1, container.invoke("Foo::SetupCountQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+      assert_equal 1, container.invoke("Foo::SetupCountQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
     end
   end
 
-  def test_call_raises_load_error_when_setup_is_missing
+  def test_invoke_raises_load_error_when_setup_is_missing
     with_module_root do |module_root|
       container = Torikago::EngineContainer.new(
         name: :foo,
@@ -418,7 +1001,7 @@ class TorikagoEngineContainerTest < Minitest::Test
       )
 
       error = assert_raises(LoadError) do
-        container.call("Foo::ListProductsQuery")
+        container.invoke("Foo::ListProductsQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
       end
 
       assert_match(/setup not found/, error.message)
@@ -426,7 +1009,7 @@ class TorikagoEngineContainerTest < Minitest::Test
     end
   end
 
-  def test_call_loads_plain_gateway_models_without_eager_loading_rails_models
+  def test_invoke_loads_plain_gateway_models_without_eager_loading_rails_models
     with_module_root do |module_root|
       model_dir = File.join(module_root, "app/models/foo")
       FileUtils.mkdir_p(model_dir)
@@ -462,12 +1045,218 @@ class TorikagoEngineContainerTest < Minitest::Test
 
       container = Torikago::EngineContainer.new(name: :foo, module_root: module_root)
 
-      assert_equal ["order"], container.call("Foo::ListOrdersQuery")
+      assert_equal ["order"], container.invoke("Foo::ListOrdersQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+    end
+  end
+
+  def test_invoke_keeps_constructor_and_method_arguments_separate
+    with_module_root do |module_root|
+      File.write(
+        File.join(module_root, "app/package_api/foo/product_query.rb"),
+        <<~RUBY
+          class Foo::ProductQuery
+            def initialize(prefix, page:)
+              @prefix = prefix
+              @page = page
+            end
+
+            def execute!(suffix, force:)
+              [@prefix, @page, suffix, force, Torikago::CurrentExecution.current_box]
+            end
+          end
+        RUBY
+      )
+      container = Torikago::EngineContainer.new(name: :foo, module_root: module_root)
+
+      result = container.invoke(
+        "Foo::ProductQuery",
+        :execute!,
+        constructor_args: ["products"],
+        constructor_kwargs: { page: 2 },
+        method_args: ["refresh"],
+        method_kwargs: { force: true }
+      )
+
+      assert_equal ["products", 2, "refresh", true, :foo], result
+      assert_nil Torikago::CurrentExecution.current_box
+    end
+  end
+
+  def test_invoke_rejects_private_methods
+    with_module_root do |module_root|
+      File.write(
+        File.join(module_root, "app/package_api/foo/private_query.rb"),
+        <<~RUBY
+          class Foo::PrivateQuery
+            private
+
+            def execute!
+              "should not run"
+            end
+          end
+        RUBY
+      )
+      container = Torikago::EngineContainer.new(name: :foo, module_root: module_root)
+
+      assert_raises(NoMethodError) do
+        container.invoke("Foo::PrivateQuery", :execute!, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+      end
+    end
+  end
+
+  def test_invoke_preserves_constructor_and_method_exceptions
+    with_module_root do |module_root|
+      File.write(
+        File.join(module_root, "app/package_api/foo/failing_query.rb"),
+        <<~RUBY
+          class Foo::FailingQuery
+            def initialize(fail_constructor: false)
+              raise "constructor failed" if fail_constructor
+            end
+
+            def execute!
+              raise "method failed"
+            end
+          end
+        RUBY
+      )
+      constructor_container = Torikago::EngineContainer.new(name: :foo, module_root: module_root)
+      method_container = Torikago::EngineContainer.new(name: :foo, module_root: module_root)
+
+      constructor_error = assert_raises(RuntimeError) do
+        constructor_container.invoke(
+          "Foo::FailingQuery",
+          :execute!,
+          constructor_args: [],
+          constructor_kwargs: { fail_constructor: true },
+          method_args: [],
+          method_kwargs: {}
+        )
+      end
+      method_error = assert_raises(RuntimeError) do
+        method_container.invoke(
+          "Foo::FailingQuery",
+          :execute!,
+          constructor_args: [],
+          constructor_kwargs: {},
+          method_args: [],
+          method_kwargs: {}
+        )
+      end
+
+      assert_equal "constructor failed", constructor_error.message
+      assert_equal "method failed", method_error.message
+    end
+  end
+
+  def test_invoke_restores_current_execution_after_nested_execution
+    with_module_root do |module_root|
+      File.write(
+        File.join(module_root, "app/package_api/foo/nested_query.rb"),
+        <<~RUBY
+          class Foo::NestedQuery
+            def execute!
+              Torikago::CurrentExecution.with_box(:bar) { :nested }
+              Torikago::CurrentExecution.current_box
+            end
+          end
+        RUBY
+      )
+      container = Torikago::EngineContainer.new(name: :foo, module_root: module_root)
+
+      result = Torikago::CurrentExecution.with_box(:caller) do
+        current = container.invoke("Foo::NestedQuery", :execute!, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+        [current, Torikago::CurrentExecution.current_box]
+      end
+
+      assert_equal [:foo, :caller], result
+      assert_nil Torikago::CurrentExecution.current_box
+    end
+  end
+
+  def test_invoke_fails_closed_when_ruby_box_creation_fails
+    with_module_root do |module_root|
+      old_ruby_box = ENV["RUBY_BOX"]
+      ENV["RUBY_BOX"] = "1"
+      container = Torikago::EngineContainer.new(
+        name: :foo,
+        module_root: module_root,
+        box_factory: -> { raise "box creation failed" }
+      )
+
+      error = assert_raises(Torikago::BoxUnavailableError) do
+        container.invoke("Foo::ListProductsQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+      end
+
+      assert_equal "Ruby::Box is unavailable for module foo: box creation failed", error.message
+      assert_instance_of RuntimeError, error.cause
+      refute Object.const_defined?(:Foo, false)
+    ensure
+      restore_env("RUBY_BOX", old_ruby_box)
+    end
+  end
+
+  def test_invoke_wraps_box_runtime_preparation_failures
+    with_module_root do |module_root|
+      old_ruby_box = ENV["RUBY_BOX"]
+      ENV["RUBY_BOX"] = "1"
+      failing_box = Object.new
+      failing_box.define_singleton_method(:load_path) { raise "load path failed" }
+      container = Torikago::EngineContainer.new(
+        name: :foo,
+        module_root: module_root,
+        box_factory: -> { failing_box }
+      )
+
+      error = assert_raises(Torikago::BoxUnavailableError) do
+        container.invoke("Foo::ListProductsQuery", :call, constructor_args: [], constructor_kwargs: {}, method_args: [], method_kwargs: {})
+      end
+
+      assert_match(/load path failed/, error.message)
+      assert_instance_of RuntimeError, error.cause
+      refute Object.const_defined?(:Foo, false)
+    ensure
+      restore_env("RUBY_BOX", old_ruby_box)
     end
   end
 
   private
 
+  class FakeBox
+    attr_reader :load_path
+
+    def initialize
+      @load_path = []
+    end
+
+    def require(_name)
+    end
+
+    def load(path)
+      Kernel.load(path)
+    end
+
+    def const_defined?(name, inherit = true)
+      Object.const_defined?(name, inherit)
+    end
+
+    def const_set(name, value)
+      Object.const_set(name, value)
+    end
+
+    def const_get(name)
+      Object.const_get(name)
+    end
+  end
+
+  def restore_env(key, value)
+    if value
+      ENV[key] = value
+    else
+      ENV.delete(key)
+    end
+  end
+
   def with_module_root
     Dir.mktmpdir("torikago-engine-container") do |module_root|
       package_api_dir = File.join(module_root, "app/package_api/foo")
@@ -519,7 +1308,12 @@ class TorikagoEngineContainerTest < Minitest::Test
 
   def assert_ruby_box_child_process(script, *args)
     stdout, stderr, status = Open3.capture3(
-      { "RUBY_BOX" => "1" },
+      {
+        "RUBY_BOX" => "1",
+        "RUBYOPT" => nil,
+        "BUNDLER_SETUP" => nil,
+        "BUNDLE_GEMFILE" => nil
+      },
       RbConfig.ruby,
       "-e",
       script,