torikago 0.0.1 → 0.1.0

data/test/torikago/checker.rb

@@ -3,152 +3,178 @@ require "fileutils"
 require "tmpdir"
 
 class TorikagoCheckerTest < Minitest::Test
-  def test_check_returns_no_errors_for_declared_calls
+  def test_check_detects_one_line_gateway_invoke
     with_project do |root, configuration|
-      FileUtils.mkdir_p(File.join(root, "modules/foo"))
-      File.write(
-        File.join(root, "modules/foo/service.rb"),
-        <<~RUBY
-          class FooService
-            def call
-              Torikago::Gateway.call("Bar::SubmitOrderCommand")
-            end
-          end
-        RUBY
-      )
-
-      checker = Torikago::Checker.new(
-        configuration: configuration,
-        source_roots: [File.join(root, "modules")]
-      )
+      write_caller(root, 'Torikago::Gateway.invoke("Bar::SubmitOrderCommand", :execute!)')
 
-      result = Dir.chdir(root) { checker.call }
+      result = check(root, configuration)
 
-      assert result.ok?
-      assert_equal [], result.errors
-      assert_equal 2, result.scanned_file_count
+      assert result.ok?, result.errors.join("\n")
       assert_equal 1, result.gateway_call_count
-      assert_equal 2, result.manifest_count
+      assert_equal 0, result.dynamic_gateway_call_count
     end
   end
 
-  def test_check_reports_undeclared_calls_and_missing_public_api_files
+  def test_check_detects_multiline_build_and_invoke
     with_project do |root, configuration|
-      FileUtils.mkdir_p(File.join(root, "modules/foo"))
-      File.write(
-        File.join(root, "modules/foo/service.rb"),
+      write_caller(
+        root,
         <<~RUBY
-          class FooService
-            def call
-              Torikago::Gateway.call("Bar::MissingCommand")
-            end
-          end
+          Torikago::Gateway
+            .build("Bar::SubmitOrderCommand", account_id: 1)
+            .invoke(:execute!, force: true)
         RUBY
       )
 
-      File.write(
-        File.join(root, "modules/bar/package_api.yml"),
-        <<~YAML
-          exports:
-            Bar::MissingCommand:
-              allowed_callers:
-                - foo
-        YAML
-      )
+      result = check(root, configuration)
 
-      checker = Torikago::Checker.new(
-        configuration: configuration,
-        source_roots: [File.join(root, "modules")]
-      )
+      assert result.ok?, result.errors.join("\n")
+      assert_equal 1, result.gateway_call_count
+    end
+  end
+
+  def test_check_reports_a_method_not_declared_in_the_manifest
+    with_project do |root, configuration|
+      write_caller(root, 'Torikago::Gateway.invoke("Bar::SubmitOrderCommand", :delete_all!)')
 
-      result = Dir.chdir(root) { checker.call }
+      result = check(root, configuration)
 
       refute result.ok?
-      assert_equal 1, result.errors.size
-      assert_match(/matching file/, result.errors.first)
+      assert(result.errors.any? { |error| error.include?("Bar::SubmitOrderCommand#delete_all! is not exported") })
     end
   end
 
-  def test_check_uses_a_configured_entrypoint_directory_when_matching_manifest_files
-    with_project(entrypoint: "components/public_api") do |root, configuration|
-      FileUtils.mkdir_p(File.join(root, "modules/foo"))
-      File.write(
-        File.join(root, "modules/foo/service.rb"),
-        <<~RUBY
-          class FooService
-            def call
-              Torikago::Gateway.call("Bar::SubmitOrderCommand")
-            end
-          end
-        RUBY
-      )
+  def test_check_reports_an_unauthorized_caller
+    with_project(allowed_callers: []) do |root, configuration|
+      write_caller(root, 'Torikago::Gateway.invoke("Bar::SubmitOrderCommand", :execute!)')
 
-      checker = Torikago::Checker.new(
-        configuration: configuration,
-        source_roots: [File.join(root, "modules")]
-      )
+      result = check(root, configuration)
+
+      refute result.ok?
+      assert(result.errors.any? { |error| error.include?("foo is not allowed to call Bar::SubmitOrderCommand#execute!") })
+    end
+  end
 
-      result = Dir.chdir(root) { checker.call }
+  def test_check_reports_manifest_entries_without_methods
+    with_project(methods: nil) do |root, configuration|
+      write_caller(root, 'Torikago::Gateway.invoke("Bar::SubmitOrderCommand", :execute!)')
 
-      assert result.ok?
-      assert_equal [], result.errors
+      result = check(root, configuration)
+
+      refute result.ok?
+      assert(result.errors.any? { |error| error.include?("must declare a non-empty methods array") })
     end
   end
 
-  def test_check_does_not_match_manifest_entries_against_parent_when_configured_entrypoint_directory_is_missing
-    Dir.mktmpdir("torikago-checker") do |root|
-      foo_root = File.join(root, "modules/foo")
-      FileUtils.mkdir_p(File.join(foo_root, "app/models/foo"))
-      File.write(File.join(foo_root, "app/models/foo/widget.rb"), "")
-      File.write(
-        File.join(foo_root, "package_api.yml"),
-        <<~YAML
-          exports:
-            Models::Foo::Widget:
-              allowed_callers: []
-        YAML
-      )
+  def test_check_reports_manifest_entries_with_empty_methods
+    with_project(methods: []) do |root, configuration|
+      result = check(root, configuration)
 
-      configuration = Torikago::Configuration.new
-      configuration.register(:foo, root: foo_root, entrypoint: "app/package_api")
+      refute result.ok?
+      assert(result.errors.any? { |error| error.include?("must declare a non-empty methods array") })
+    end
+  end
 
-      checker = Torikago::Checker.new(
-        configuration: configuration,
-        source_roots: [File.join(root, "modules")]
-      )
+  def test_check_reports_missing_public_api_files
+    with_project do |root, configuration|
+      FileUtils.rm_f(File.join(root, "modules/bar/app/package_api/bar/submit_order_command.rb"))
+
+      result = check(root, configuration)
+
+      refute result.ok?
+      assert(result.errors.any? { |error| error.include?("does not have a matching file") })
+    end
+  end
+
+  def test_check_reports_exported_methods_missing_from_the_implementation
+    with_project(implementation_method: :call) do |root, configuration|
+      result = check(root, configuration)
+
+      refute result.ok?
+      assert(result.errors.any? { |error| error.include?("#execute! is exported but no public instance method definition was found") })
+    end
+  end
 
-      result = Dir.chdir(root) { checker.call }
+  def test_check_does_not_treat_private_methods_as_public_implementations
+    with_project(implementation_visibility: :private) do |root, configuration|
+      result = check(root, configuration)
 
       refute result.ok?
-      assert_equal 1, result.errors.size
-      assert_match(/matching file/, result.errors.first)
+      assert(result.errors.any? { |error| error.include?("no public instance method definition") })
+    end
+  end
+
+  def test_check_skips_dynamic_gateway_arguments_and_counts_them_separately
+    with_project do |root, configuration|
+      write_caller(root, "Torikago::Gateway.invoke(class_name, method_name)")
+
+      result = check(root, configuration)
+
+      assert result.ok?, result.errors.join("\n")
+      assert_equal 0, result.gateway_call_count
+      assert_equal 1, result.dynamic_gateway_call_count
+    end
+  end
+
+  def test_check_uses_a_configured_entrypoint_directory
+    with_project(entrypoint: "components/public_api") do |root, configuration|
+      write_caller(root, 'Torikago::Gateway.invoke("Bar::SubmitOrderCommand", :execute!)')
+
+      result = check(root, configuration)
+
+      assert result.ok?, result.errors.join("\n")
     end
   end
 
   private
 
-  def with_project(entrypoint: nil)
+  def check(root, configuration)
+    checker = Torikago::Checker.new(
+      configuration: configuration,
+      source_roots: [File.join(root, "modules")]
+    )
+    Dir.chdir(root) { checker.call }
+  end
+
+  def write_caller(root, invocation)
+    FileUtils.mkdir_p(File.join(root, "modules/foo"))
+    File.write(
+      File.join(root, "modules/foo/service.rb"),
+      <<~RUBY
+        class FooService
+          def call
+            #{invocation}
+          end
+        end
+      RUBY
+    )
+  end
+
+  def with_project(entrypoint: nil, methods: ["execute!"], allowed_callers: ["foo"], implementation_method: :execute!, implementation_visibility: :public)
     Dir.mktmpdir("torikago-checker") do |root|
       foo_root = File.join(root, "modules/foo")
       bar_root = File.join(root, "modules/bar")
       public_api_root = entrypoint ? File.join(bar_root, entrypoint, "bar") : File.join(bar_root, "app/package_api/bar")
+      FileUtils.mkdir_p(foo_root)
       FileUtils.mkdir_p(public_api_root)
 
+      methods_yaml = methods.nil? ? "" : "    methods:\n#{methods.map { |method| "      - #{method}" }.join("\n")}\n"
       File.write(
         File.join(bar_root, "package_api.yml"),
         <<~YAML
           exports:
             Bar::SubmitOrderCommand:
-              allowed_callers:
-                - foo
+          #{methods_yaml}    allowed_callers:
+          #{allowed_callers.map { |caller| "      - #{caller}" }.join("\n")}
         YAML
       )
 
+      visibility = implementation_visibility == :public ? "" : "  #{implementation_visibility}\n\n"
       File.write(
         File.join(public_api_root, "submit_order_command.rb"),
         <<~RUBY
           class Bar::SubmitOrderCommand
-            def call
+          #{visibility}  def #{implementation_method}
             end
           end
         RUBY

data/test/torikago/cli.rb

@@ -55,8 +55,8 @@ class TorikagoCliTest < Minitest::Test
       bar_manifest = YAML.safe_load(File.read(File.join(root, "modules/bar/package_api.yml")))
       initializer = File.read(File.join(root, "config/initializers/torikago.rb"))
 
-      assert_equal({ "allowed_callers" => [] }, foo_manifest.dig("exports", "Foo::ListProductsQuery"))
-      assert_equal({ "allowed_callers" => [] }, bar_manifest.dig("exports", "Bar::SubmitOrderCommand"))
+      assert_equal({ "methods" => [], "allowed_callers" => [] }, foo_manifest.dig("exports", "Foo::ListProductsQuery"))
+      assert_equal({ "methods" => [], "allowed_callers" => [] }, bar_manifest.dig("exports", "Bar::SubmitOrderCommand"))
       assert_match(/root: Rails\.root\.join\("modules\/bar"\)/, initializer)
       assert_match(/entrypoint: "components\/public_api"/, initializer)
       assert_match(/root: Rails\.root\.join\("modules\/foo"\)/, initializer)
@@ -66,6 +66,19 @@ class TorikagoCliTest < Minitest::Test
     end
   end
 
+  def test_render_initializer_includes_setup_option
+    configuration = Torikago::Configuration.new
+    configuration.register(
+      :foo,
+      root: "modules/foo",
+      setup: "config/box_setup.rb"
+    )
+
+    initializer = Torikago::CLI.new.send(:render_initializer, configuration)
+
+    assert_match(/setup: "config\/box_setup\.rb"/, initializer)
+  end
+
   def test_check_prints_summary_information
     with_cli_project do |root|
       stdout = StringIO.new
@@ -77,7 +90,7 @@ class TorikagoCliTest < Minitest::Test
 
       assert_equal 0, exit_code
       assert_match(/scanned 2 Ruby files/, stdout.string)
-      assert_match(/found 1 Gateway\.call usages/, stdout.string)
+      assert_match(/found 1 static Gateway invocations/, stdout.string)
       assert_match(/validated 2 package_api manifests/, stdout.string)
       assert_equal "", stderr.string
     end
@@ -111,7 +124,7 @@ class TorikagoCliTest < Minitest::Test
         <<~RUBY
           class FooService
             def call
-              Torikago::Gateway.call("Bar::SubmitOrderCommand")
+              Torikago::Gateway.invoke("Bar::SubmitOrderCommand", :call)
             end
           end
         RUBY
@@ -122,6 +135,8 @@ class TorikagoCliTest < Minitest::Test
         <<~YAML
           exports:
             Bar::SubmitOrderCommand:
+              methods:
+                - call
               allowed_callers:
                 - foo
         YAML

data/test/torikago/configuration.rb

@@ -10,6 +10,7 @@ class TorikagoConfigurationTest < Minitest::Test
       :foo,
       root: "/modules/foo",
       entrypoint: "lib/foo/box_runtime.rb",
+      rails_engine: true,
       setup: "config/box_setup.rb",
       gemfile: "Gemfile"
     )
@@ -19,6 +20,7 @@ class TorikagoConfigurationTest < Minitest::Test
     assert_equal :foo, definition.name
     assert_equal "/modules/foo", definition.root.to_s
     assert_equal "lib/foo/box_runtime.rb", definition.entrypoint
+    assert_equal true, definition.rails_engine
     assert_equal "config/box_setup.rb", definition.setup
     assert_equal "Gemfile", definition.gemfile
   end

data/test/torikago/controller_endpoint.rb

@@ -0,0 +1,30 @@
+require_relative "../test_helper"
+
+class TorikagoControllerEndpointTest < Minitest::Test
+  def test_call_dispatches_to_a_box_owned_controller
+    received = nil
+    container = Object.new
+    container.define_singleton_method(:dispatch_controller) do |env, controller_name:, action_name:|
+      received = [env, controller_name, action_name]
+      [200, { "content-type" => "text/plain" }, ["ok"]]
+    end
+
+    registry = Object.new
+    registry.define_singleton_method(:resolve) do |name|
+      raise "unexpected module: #{name}" unless name == :foo
+
+      container
+    end
+
+    endpoint = Torikago::ControllerEndpoint.new(
+      "foo",
+      "WidgetsController",
+      "show",
+      registry: registry
+    )
+    env = { "PATH_INFO" => "/widgets/7" }
+
+    assert_equal [200, { "content-type" => "text/plain" }, ["ok"]], endpoint.call(env)
+    assert_equal [env, "WidgetsController", :show], received
+  end
+end