torikago 0.0.1 → 0.1.0

data/test/torikago/gateway.rb

@@ -1,23 +1,21 @@
 require_relative "../test_helper"
-require "fileutils"
-require "tmpdir"
 
 class TorikagoGatewayTest < Minitest::Test
-  FakeContainer = Struct.new(:calls) do
-    def call(public_api_class_name, *args, **kwargs)
-      calls << [public_api_class_name, args, kwargs]
-      "result for #{public_api_class_name}"
+  FakeContainer = Struct.new(:invocations) do
+    def invoke(public_api_class_name, method_name, **arguments)
+      invocations << [public_api_class_name, method_name, arguments]
+      "result for #{public_api_class_name}##{method_name}"
     end
   end
 
   class FakeRegistry
+    attr_reader :resolved
+
     def initialize(containers)
       @containers = containers
-      @resolved = []
+      @resolved = Array.new
     end
 
-    attr_reader :resolved
-
     def resolve(name)
       normalized_name = name.to_sym
       resolved << normalized_name
@@ -25,131 +23,179 @@ class TorikagoGatewayTest < Minitest::Test
     end
   end
 
-  def test_class_level_call_delegates_to_the_shared_gateway
+  def test_class_level_build_and_invoke_delegate_to_the_shared_gateway
     original_gateway = Torikago.instance_variable_get(:@gateway)
     fake_gateway = Object.new
-    called_with = nil
-
-    fake_gateway.define_singleton_method(:call) do |*args, **kwargs|
-      called_with = [args, kwargs]
-      "ok"
-    end
-
+    calls = Array.new
+    fake_gateway.define_singleton_method(:build) { |*args, **kwargs| calls << [:build, args, kwargs]; "build" }
+    fake_gateway.define_singleton_method(:invoke) { |*args, **kwargs| calls << [:invoke, args, kwargs]; "invoke" }
     Torikago.instance_variable_set(:@gateway, fake_gateway)
 
-    result = Torikago::Gateway.call("Foo::ListProductsQuery", page: 1)
-
-    assert_equal "ok", result
-    assert_equal [["Foo::ListProductsQuery"], { page: 1 }], called_with
+    assert_equal "build", Torikago::Gateway.build("Foo::Query", 1, page: 2)
+    assert_equal "invoke", Torikago::Gateway.invoke("Foo::Query", :execute!, 3, force: true)
+    assert_equal(
+      [
+        [:build, ["Foo::Query", 1], { page: 2 }],
+        [:invoke, ["Foo::Query", :execute!, 3], { force: true }]
+      ],
+      calls
+    )
   ensure
     Torikago.instance_variable_set(:@gateway, original_gateway)
   end
 
-  def test_call_delegates_to_the_target_module_container
-    configuration = Torikago::Configuration.new
-    configuration.register(:foo, root: "/modules/foo")
-    write_package_api_manifest("/modules/foo", "Foo::ListProductsQuery" => { "allowed_callers" => [] })
+  def test_build_holds_constructor_arguments_until_invoke
+    gateway, registry, container = build_gateway
 
-    container = FakeContainer.new([])
-    registry = FakeRegistry.new(foo: container)
-    gateway = Torikago::Gateway.new(
-      registry: registry,
-      configuration: configuration,
-      manifest_loader: ->(_definition) { { "exports" => { "Foo::ListProductsQuery" => { "allowed_callers" => [] } } } }
+    invocation = gateway.build("Foo::ProductQuery", 10, page: 2)
+
+    assert_empty registry.resolved
+    result = invocation.invoke(:execute!, 20, force: true)
+
+    assert_equal "result for Foo::ProductQuery#execute!", result
+    assert_equal [:foo], registry.resolved
+    assert_equal(
+      [
+        [
+          "Foo::ProductQuery",
+          :execute!,
+          {
+            constructor_args: [10],
+            constructor_kwargs: { page: 2 },
+            method_args: [20],
+            method_kwargs: { force: true }
+          }
+        ]
+      ],
+      container.invocations
     )
+  end
+
+  def test_invoke_dispatches_with_an_argumentless_constructor
+    gateway, registry, container = build_gateway
 
-    result = gateway.call("Foo::ListProductsQuery", page: 1)
+    gateway.invoke("Foo::ProductQuery", :execute!, 20, force: true)
 
-    assert_equal "result for Foo::ListProductsQuery", result
     assert_equal [:foo], registry.resolved
-    assert_equal [["Foo::ListProductsQuery", [], { page: 1 }]], container.calls
+    assert_equal [], container.invocations.first[2].fetch(:constructor_args)
+    assert_equal({}, container.invocations.first[2].fetch(:constructor_kwargs))
+    assert_equal [20], container.invocations.first[2].fetch(:method_args)
+    assert_equal({ force: true }, container.invocations.first[2].fetch(:method_kwargs))
   end
 
-  def test_call_rejects_public_api_not_declared_in_package_api_manifest
-    configuration = Torikago::Configuration.new
-    configuration.register(:foo, root: "/modules/foo")
-    registry = FakeRegistry.new(foo: FakeContainer.new([]))
-    gateway = Torikago::Gateway.new(
-      registry: registry,
-      configuration: configuration,
-      manifest_loader: ->(_definition) { { "exports" => {} } }
-    )
+  def test_gateway_does_not_expose_call
+    gateway, = build_gateway
+
+    refute_respond_to Torikago::Gateway, :call
+    refute_respond_to gateway, :call
+  end
+
+  def test_invoke_rejects_a_class_not_declared_in_the_manifest_before_resolving
+    gateway, registry = build_gateway(exports: Hash.new)
 
     error = assert_raises(Torikago::PublicApiError) do
-      gateway.call("Foo::MissingCommand")
+      gateway.invoke("Foo::MissingCommand", :execute!)
     end
 
-    assert_match(/Foo::MissingCommand/, error.message)
+    assert_match(/Foo::MissingCommand#execute!/, error.message)
+    assert_empty registry.resolved
   end
 
-  def test_call_allows_host_app_invocation_without_allowed_callers
-    configuration = Torikago::Configuration.new
-    configuration.register(:foo, root: "/modules/foo")
-    container = FakeContainer.new([])
-    registry = FakeRegistry.new(foo: container)
-    gateway = Torikago::Gateway.new(
-      registry: registry,
-      configuration: configuration,
-      manifest_loader: ->(_definition) { { "exports" => { "Foo::ListProductsQuery" => { "allowed_callers" => [] } } } }
-    )
+  def test_invoke_rejects_a_method_not_declared_in_the_manifest_before_resolving
+    gateway, registry = build_gateway
 
-    gateway.call("Foo::ListProductsQuery")
+    error = assert_raises(Torikago::PublicApiError) do
+      gateway.invoke("Foo::ProductQuery", :delete_all!)
+    end
 
-    assert_equal [["Foo::ListProductsQuery", [], {}]], container.calls
+    assert_equal "package api method is not exported: Foo::ProductQuery#delete_all!", error.message
+    assert_empty registry.resolved
   end
 
-  def test_call_allows_box_dependency_declared_in_package_api_manifest
-    configuration = Torikago::Configuration.new
-    configuration.register(:foo, root: "/modules/foo")
-    configuration.register(:bar, root: "/modules/bar")
-    bar_container = FakeContainer.new([])
-    registry = FakeRegistry.new(foo: FakeContainer.new([]), bar: bar_container)
+  def test_invoke_rejects_manifest_entries_without_methods
+    gateway, registry = build_gateway(
+      exports: { "Foo::ProductQuery" => { "allowed_callers" => [] } }
+    )
 
-    gateway = Torikago::Gateway.new(
-      registry: registry,
-      configuration: configuration,
-      manifest_loader: lambda do |definition|
-        if definition.name == :bar
-          { "exports" => { "Bar::SubmitOrderCommand" => { "allowed_callers" => ["foo"] } } }
-        else
-          { "exports" => {} }
-        end
-      end
+    error = assert_raises(Torikago::PublicApiError) do
+      gateway.invoke("Foo::ProductQuery", :execute!)
+    end
+
+    assert_match(/methods are not configured/, error.message)
+    assert_empty registry.resolved
+  end
+
+  def test_invoke_rejects_manifest_entries_with_empty_methods
+    gateway, registry = build_gateway(
+      exports: { "Foo::ProductQuery" => { "methods" => [], "allowed_callers" => [] } }
     )
 
-    Torikago::CurrentExecution.with_box(:foo) do
-      result = gateway.call("Bar::SubmitOrderCommand", order_id: 1)
+    assert_raises(Torikago::PublicApiError) do
+      gateway.invoke("Foo::ProductQuery", :execute!)
+    end
+    assert_empty registry.resolved
+  end
+
+  def test_invoke_allows_the_host_app_without_allowed_callers
+    gateway, _, container = build_gateway
+
+    gateway.invoke("Foo::ProductQuery", :execute!)
+
+    assert_equal 1, container.invocations.size
+  end
+
+  def test_invoke_allows_the_target_module_to_call_itself
+    gateway, _, container = build_gateway
 
-      assert_equal "result for Bar::SubmitOrderCommand", result
+    Torikago::CurrentExecution.with_box(:foo) do
+      gateway.invoke("Foo::ProductQuery", :execute!)
     end
 
-    assert_equal [["Bar::SubmitOrderCommand", [], { order_id: 1 }]], bar_container.calls
+    assert_equal 1, container.invocations.size
   end
 
-  def test_call_rejects_box_dependency_not_declared_in_package_api_manifest
-    configuration = Torikago::Configuration.new
-    configuration.register(:foo, root: "/modules/foo")
-    configuration.register(:bar, root: "/modules/bar")
-    registry = FakeRegistry.new(foo: FakeContainer.new([]), bar: FakeContainer.new([]))
+  def test_invoke_allows_a_declared_cross_module_caller
+    gateway, _, container = build_gateway(allowed_callers: ["bar"])
 
-    gateway = Torikago::Gateway.new(
-      registry: registry,
-      configuration: configuration,
-      manifest_loader: ->(_definition) { { "exports" => { "Bar::SubmitOrderCommand" => { "allowed_callers" => ["admin"] } } } }
-    )
+    Torikago::CurrentExecution.with_box(:bar) do
+      gateway.invoke("Foo::ProductQuery", :execute!)
+    end
+
+    assert_equal 1, container.invocations.size
+  end
+
+  def test_invoke_rejects_an_undeclared_cross_module_caller_before_resolving
+    gateway, registry = build_gateway(allowed_callers: ["admin"])
 
     error = assert_raises(Torikago::DependencyError) do
-      Torikago::CurrentExecution.with_box(:foo) do
-        gateway.call("Bar::SubmitOrderCommand")
+      Torikago::CurrentExecution.with_box(:bar) do
+        gateway.invoke("Foo::ProductQuery", :execute!)
       end
     end
 
-    assert_match(/foo/, error.message)
-    assert_match(/bar/i, error.message)
+    assert_match(/bar -> foo#Foo::ProductQuery#execute!/, error.message)
+    assert_empty registry.resolved
   end
 
   private
 
-  def write_package_api_manifest(_root, _entries)
+  def build_gateway(allowed_callers: [], exports: nil)
+    configuration = Torikago::Configuration.new
+    configuration.register(:foo, root: "/modules/foo")
+    container = FakeContainer.new(Array.new)
+    registry = FakeRegistry.new(foo: container)
+    exports ||= {
+      "Foo::ProductQuery" => {
+        "methods" => ["execute!"],
+        "allowed_callers" => allowed_callers
+      }
+    }
+    gateway = Torikago::Gateway.new(
+      registry: registry,
+      configuration: configuration,
+      manifest_loader: ->(_definition) { { "exports" => exports } }
+    )
+
+    [gateway, registry, container]
   end
 end

data/test/torikago/package_api_updater.rb

@@ -22,8 +22,8 @@ class TorikagoPackageApiUpdaterTest < Minitest::Test
       assert_equal(
         {
           "exports" => {
-            "Foo::UserCreateCommand" => { "allowed_callers" => [] },
-            "Foo::UserFindQuery" => { "allowed_callers" => [] }
+            "Foo::UserCreateCommand" => { "methods" => [], "allowed_callers" => [] },
+            "Foo::UserFindQuery" => { "methods" => [], "allowed_callers" => [] }
           }
         },
         manifest
@@ -42,6 +42,8 @@ class TorikagoPackageApiUpdaterTest < Minitest::Test
         <<~YAML
           exports:
             Foo::UserCreateCommand:
+              methods:
+                - execute!
               allowed_callers:
                 - bar
         YAML
@@ -54,6 +56,7 @@ class TorikagoPackageApiUpdaterTest < Minitest::Test
       manifest = YAML.safe_load(File.read(File.join(module_root, "package_api.yml")))
 
       assert_equal ["bar"], manifest.dig("exports", "Foo::UserCreateCommand", "allowed_callers")
+      assert_equal ["execute!"], manifest.dig("exports", "Foo::UserCreateCommand", "methods")
     end
   end
 
@@ -71,7 +74,7 @@ class TorikagoPackageApiUpdaterTest < Minitest::Test
       manifest = YAML.safe_load(File.read(File.join(module_root, "package_api.yml")))
 
       assert_equal(
-        { "allowed_callers" => [] },
+        { "methods" => [], "allowed_callers" => [] },
         manifest.dig("exports", "Foo::UserCreateCommand")
       )
     end

data/test/torikago/rack_endpoint.rb

@@ -0,0 +1,25 @@
+require_relative "../test_helper"
+
+class TorikagoRackEndpointTest < Minitest::Test
+  def test_call_resolves_and_dispatches_to_the_registered_module
+    received_env = nil
+    container = Object.new
+    container.define_singleton_method(:call) do |env|
+      received_env = env
+      [204, {}, []]
+    end
+
+    registry = Object.new
+    registry.define_singleton_method(:resolve) do |name|
+      raise "unexpected module: #{name}" unless name == :foo
+
+      container
+    end
+
+    endpoint = Torikago::RackEndpoint.new("foo", registry: registry)
+    env = { "PATH_INFO" => "/widgets" }
+
+    assert_equal [204, {}, []], endpoint.call(env)
+    assert_same env, received_env
+  end
+end

data/test/torikago/registry.rb

@@ -7,6 +7,7 @@ class TorikagoRegistryTest < Minitest::Test
       :foo,
       root: "/modules/foo",
       entrypoint: "lib/foo/box_runtime.rb",
+      rails_engine: true,
       setup: "config/box_setup.rb",
       gemfile: "Gemfile"
     )
@@ -18,6 +19,7 @@ class TorikagoRegistryTest < Minitest::Test
         name: definition.name,
         root: definition.root.to_s,
         entrypoint: definition.entrypoint,
+        rails_engine: definition.rails_engine,
         setup: definition.setup,
         gemfile: definition.gemfile
       }
@@ -28,6 +30,7 @@ class TorikagoRegistryTest < Minitest::Test
     assert_equal :foo, container[:name]
     assert_equal "/modules/foo", container[:root]
     assert_equal "lib/foo/box_runtime.rb", container[:entrypoint]
+    assert_equal true, container[:rails_engine]
     assert_equal "config/box_setup.rb", container[:setup]
     assert_equal "Gemfile", container[:gemfile]
   end
@@ -80,4 +83,16 @@ class TorikagoRegistryTest < Minitest::Test
 
     assert_instance_of Torikago::EngineContainer, container
   end
+
+  def test_default_container_receives_every_registered_root
+    @configuration.register(:bar, root: "/components/bar")
+    registry = Torikago::Registry.new(configuration: @configuration)
+
+    container = registry.resolve(:foo)
+
+    assert_equal(
+      [Pathname("/modules/foo"), Pathname("/components/bar")],
+      container.send(:registered_roots)
+    )
+  end
 end

data/test/torikago/root_constant_resolver.rb

@@ -0,0 +1,114 @@
+require_relative "../test_helper"
+require "fileutils"
+require "tmpdir"
+
+class TorikagoRootConstantResolverTest < Minitest::Test
+  def teardown
+    Object.send(:remove_const, :RootResolverVisibleConstant) if Object.const_defined?(:RootResolverVisibleConstant, false)
+    Object.send(:remove_const, :RootResolverRegisteredConstant) if Object.const_defined?(:RootResolverRegisteredConstant, false)
+    Object.send(:remove_const, :RootResolverRegisteredAutoload) if Object.const_defined?(:RootResolverRegisteredAutoload, false)
+    Object.send(:remove_const, :RootResolverSharedNamespace) if Object.const_defined?(:RootResolverSharedNamespace, false)
+  end
+
+  def test_resolve_returns_main_constant_defined_outside_registered_roots
+    Dir.mktmpdir("torikago-root-resolver") do |application_root|
+      registered_root = File.join(application_root, "modules/foo")
+      FileUtils.mkdir_p(registered_root)
+      root_file = File.join(application_root, "app_root_constant.rb")
+      File.write(root_file, "class RootResolverVisibleConstant; end\n")
+      load root_file
+
+      resolver = Torikago::RootConstantResolver.new(
+        registered_roots: [registered_root],
+        main_box: Object
+      )
+
+      assert_same RootResolverVisibleConstant, resolver.resolve(:RootResolverVisibleConstant)
+    end
+  end
+
+  def test_resolve_rejects_constants_defined_below_any_registered_root
+    Dir.mktmpdir("torikago-root-resolver") do |application_root|
+      registered_root = File.join(application_root, "packs/foo")
+      FileUtils.mkdir_p(registered_root)
+      registered_file = File.join(registered_root, "registered_constant.rb")
+      File.write(registered_file, "class RootResolverRegisteredConstant; end\n")
+      load registered_file
+
+      resolver = Torikago::RootConstantResolver.new(
+        registered_roots: [registered_root],
+        main_box: Object
+      )
+
+      assert_same resolver.unresolved, resolver.resolve(:RootResolverRegisteredConstant)
+    end
+  end
+
+  def test_resolve_returns_unresolved_for_an_unknown_constant
+    resolver = Torikago::RootConstantResolver.new(
+      registered_roots: [],
+      main_box: Object
+    )
+
+    assert_same resolver.unresolved, resolver.resolve(:RootResolverMissingConstant)
+  end
+
+  def test_resolve_rejects_a_top_level_autoload_from_a_registered_root
+    Dir.mktmpdir("torikago-root-resolver") do |application_root|
+      registered_root = File.join(application_root, "modules/foo")
+      FileUtils.mkdir_p(registered_root)
+      registered_file = File.join(registered_root, "registered_autoload.rb")
+      File.write(registered_file, "class RootResolverRegisteredAutoload; end\n")
+      Object.autoload(:RootResolverRegisteredAutoload, registered_file)
+
+      resolver = Torikago::RootConstantResolver.new(
+        registered_roots: [registered_root],
+        main_box: Object
+      )
+
+      assert_same resolver.unresolved, resolver.resolve(:RootResolverRegisteredAutoload)
+      assert_equal registered_file, Object.autoload?(:RootResolverRegisteredAutoload, false)
+    end
+  end
+
+  def test_resolve_rejects_a_root_namespace_with_a_registered_descendant
+    Dir.mktmpdir("torikago-root-resolver") do |application_root|
+      registered_root = File.join(application_root, "components/bar")
+      FileUtils.mkdir_p(registered_root)
+      root_file = File.join(application_root, "shared_namespace.rb")
+      registered_file = File.join(registered_root, "internal.rb")
+      File.write(root_file, "module RootResolverSharedNamespace; end\n")
+      File.write(registered_file, "class RootResolverSharedNamespace::Internal; end\n")
+      load root_file
+      load registered_file
+
+      resolver = Torikago::RootConstantResolver.new(
+        registered_roots: [registered_root],
+        main_box: Object
+      )
+
+      assert_same resolver.unresolved, resolver.resolve(:RootResolverSharedNamespace)
+    end
+  end
+
+  def test_resolve_rejects_a_root_namespace_with_a_registered_autoload
+    Dir.mktmpdir("torikago-root-resolver") do |application_root|
+      registered_root = File.join(application_root, "components/bar")
+      FileUtils.mkdir_p(registered_root)
+      root_file = File.join(application_root, "shared_namespace.rb")
+      registered_file = File.join(registered_root, "autoloaded_internal.rb")
+      File.write(root_file, "module RootResolverSharedNamespace; end\n")
+      File.write(registered_file, "class RootResolverSharedNamespace::AutoloadedInternal; end\n")
+      load root_file
+      RootResolverSharedNamespace.autoload(:AutoloadedInternal, registered_file)
+
+      resolver = Torikago::RootConstantResolver.new(
+        registered_roots: [registered_root],
+        main_box: Object
+      )
+
+      assert_same resolver.unresolved, resolver.resolve(:RootResolverSharedNamespace)
+      assert_equal registered_file, RootResolverSharedNamespace.autoload?(:AutoloadedInternal, false)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: torikago
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
   - se4weed
@@ -29,22 +29,30 @@ files:
   - lib/torikago/checker.rb
   - lib/torikago/cli.rb
   - lib/torikago/configuration.rb
+  - lib/torikago/controller_endpoint.rb
   - lib/torikago/current_execution.rb
   - lib/torikago/engine_container.rb
   - lib/torikago/errors.rb
   - lib/torikago/gateway.rb
+  - lib/torikago/invocation.rb
   - lib/torikago/package_api_updater.rb
+  - lib/torikago/rack_endpoint.rb
   - lib/torikago/registry.rb
+  - lib/torikago/root_constant_resolver.rb
   - lib/torikago/version.rb
+  - sig/torikago.rbs
   - test/test_helper.rb
   - test/torikago.rb
   - test/torikago/checker.rb
   - test/torikago/cli.rb
   - test/torikago/configuration.rb
+  - test/torikago/controller_endpoint.rb
   - test/torikago/engine_container.rb
   - test/torikago/gateway.rb
   - test/torikago/package_api_updater.rb
+  - test/torikago/rack_endpoint.rb
   - test/torikago/registry.rb
+  - test/torikago/root_constant_resolver.rb
   - test/torikago/version.rb
 homepage: "https://github.com/se4weed/torikago"
 licenses: