${escapeHtml(error.stack || '')}
+ ${escapeHtml(error.stack || '')}
+ ${escapeHtml(error.stack || '')}
+
+ return (
+
{children}
)
diff --git a/test/phoenix/mix/build/deno_integration_test.exs b/test/phoenix/mix/build/deno_integration_test.exs
new file mode 100644
index 0000000..604c60c
--- /dev/null
+++ b/test/phoenix/mix/build/deno_integration_test.exs
@@ -0,0 +1,80 @@
+defmodule Mix.Tasks.Phx.React.Deno.BundleIntegrationTest do
+ use ExUnit.Case, async: false
+
+ alias Mix.Tasks.Phx.React.Deno.Bundle
+
+ describe "bundle integration tests" do
+ @describetag :integration
+
+ test "find_files handles complex directory structures" do
+ tmp_dir = System.tmp_dir!()
+ test_dir = Path.join(tmp_dir, "deno_bundle_test_#{System.unique_integer()}")
+
+ # Create complex directory structure
+ File.mkdir_p!(test_dir)
+ File.mkdir_p!(Path.join([test_dir, "components"]))
+ File.mkdir_p!(Path.join([test_dir, "components", "ui"]))
+ File.mkdir_p!(Path.join([test_dir, "utils"]))
+
+ # Create various files
+ files = [
+ {"component1.js", "export const Component = () => null;"},
+ {"components/component2.js", "export const Component = () => null;"},
+ {"components/ui/button.js", "export const Component = () => null;"},
+ {"utils/helper.js", "export const helper = () => null;"},
+ {"README.md", "# Documentation"}
+ ]
+
+ for {path, content} <- files do
+ path_parts = [test_dir | String.split(path, "/")]
+ full_path = Path.join(path_parts)
+ File.mkdir_p!(Path.dirname(full_path))
+ File.write!(full_path, content)
+ end
+
+ try do
+ found_files = Bundle.find_files(test_dir)
+
+ # Should find all files
+ assert length(found_files) >= 5
+
+ # Check that specific files are found
+ file_names = Enum.map(found_files, &Path.basename/1)
+ assert "component1.js" in file_names
+ assert "component2.js" in file_names
+ assert "button.js" in file_names
+ assert "helper.js" in file_names
+ assert "README.md" in file_names
+ after
+ File.rm_rf!(test_dir)
+ end
+ end
+
+ test "find_files handles empty directory" do
+ tmp_dir = System.tmp_dir!()
+ test_dir = Path.join(tmp_dir, "empty_test_#{System.unique_integer()}")
+ File.mkdir_p!(test_dir)
+
+ try do
+ files = Bundle.find_files(test_dir)
+ assert files == []
+ after
+ File.rm_rf!(test_dir)
+ end
+ end
+
+ test "find_files handles permission errors gracefully" do
+ # Test with a path that doesn't exist
+ non_existent = "/tmp/definitely_does_not_exist_#{System.unique_integer()}"
+
+ files = Bundle.find_files(non_existent)
+ assert files == []
+ end
+
+ test "bundle task handles invalid arguments" do
+ assert_raise ArgumentError, ~r/component_base dir does not exist/, fn ->
+ Bundle.run(["--component-base", "/non/existent/path", "--output", "/tmp/output.js"])
+ end
+ end
+ end
+end
diff --git a/test/phoenix/mix/build/deno_test.exs b/test/phoenix/mix/build/deno_test.exs
new file mode 100644
index 0000000..a884c26
--- /dev/null
+++ b/test/phoenix/mix/build/deno_test.exs
@@ -0,0 +1,48 @@
+defmodule Mix.Tasks.Phx.React.Deno.BundleTest do
+ use ExUnit.Case, async: false
+
+ alias Mix.Tasks.Phx.React.Deno.Bundle
+
+ describe "run/1" do
+ test "handles missing arguments gracefully" do
+ # Test that the function can be called
+ # The actual error handling depends on the OptionParser behavior
+ assert is_function(&Bundle.run/1)
+ end
+
+ test "find_files/1 finds all files in directory recursively" do
+ # Create a temporary directory structure
+ tmp_dir = System.tmp_dir!()
+ test_dir = Path.join(tmp_dir, "deno_test_#{System.unique_integer()}")
+ File.mkdir_p!(test_dir)
+
+ # Create some test files
+ File.write!(Path.join(test_dir, "component1.js"), "export const Component = () => null;")
+ File.mkdir!(Path.join(test_dir, "subdir"))
+
+ File.write!(
+ Path.join([test_dir, "subdir", "component2.js"]),
+ "export const Component = () => null;"
+ )
+
+ try do
+ files = Bundle.find_files(test_dir)
+
+ # Should find both files
+ assert length(files) == 2
+ assert Enum.any?(files, &String.ends_with?(&1, "component1.js"))
+ assert Enum.any?(files, &String.ends_with?(&1, "component2.js"))
+ after
+ File.rm_rf!(test_dir)
+ end
+ end
+
+ test "find_files/1 handles non-existent directory" do
+ non_existent = "/tmp/non_existent_#{System.unique_integer()}"
+
+ # Should return empty list for non-existent directory
+ files = Bundle.find_files(non_existent)
+ assert files == []
+ end
+ end
+end
diff --git a/test/phoenix/mix/build/server_deno_template_test.exs b/test/phoenix/mix/build/server_deno_template_test.exs
new file mode 100644
index 0000000..5d44b81
--- /dev/null
+++ b/test/phoenix/mix/build/server_deno_template_test.exs
@@ -0,0 +1,67 @@
+defmodule Mix.Tasks.Phx.React.Deno.ServerTemplateTest do
+ use ExUnit.Case, async: true
+
+ describe "server_deno.js.eex template" do
+ test "template compiles correctly with sample files" do
+ files = [
+ {"component1", "/path/to/component1.js"},
+ {"component2", "/path/to/component2.js"}
+ ]
+
+ base_dir = "/test/components"
+
+ # Read and compile the template
+ template_path = Path.expand("../../../../lib/phoenix/mix/build/server_deno.js.eex", __DIR__)
+ quoted = EEx.compile_file(template_path)
+
+ # Evaluate the template
+ {result, _bindings} = Code.eval_quoted(quoted, files: files, base_dir: base_dir)
+
+ # Check that the result contains expected imports
+ assert String.contains?(
+ result,
+ "import { Component as __component_0 } from \"/path/to/component1.js\""
+ )
+
+ assert String.contains?(
+ result,
+ "import { Component as __component_1 } from \"/path/to/component2.js\""
+ )
+
+ # Check that component mapping is created
+ assert String.contains?(result, "__comMap[\"component1\"] = __component_0")
+ assert String.contains?(result, "__comMap[\"component2\"] = __component_1")
+
+ # Check that Deno-specific imports are present
+ assert String.contains?(result, "import { serve } from \"https://deno.land/std")
+
+ assert String.contains?(
+ result,
+ "import { renderToReadableStream, renderToString, renderToStaticMarkup } from \"npm:react-dom/server\""
+ )
+
+ # Check that environment variables are used
+ assert String.contains?(result, "DENO_ENV")
+ assert String.contains?(result, "COMPONENT_BASE")
+
+ # Check that server setup is present
+ assert String.contains?(result, "await serve")
+ assert String.contains?(result, "Deno.addSignalListener")
+ end
+
+ test "template handles empty files list" do
+ files = []
+ base_dir = "/test/components"
+
+ template_path = Path.expand("../../../../lib/phoenix/mix/build/server_deno.js.eex", __DIR__)
+ quoted = EEx.compile_file(template_path)
+
+ {result, _bindings} = Code.eval_quoted(quoted, files: files, base_dir: base_dir)
+
+ # Should still contain the basic structure
+ assert String.contains?(result, "const __comMap = {};")
+ assert String.contains?(result, "import { serve } from")
+ assert String.contains?(result, "await serve")
+ end
+ end
+end
diff --git a/test/phoenix/react/runtime/deno_integration_test.exs b/test/phoenix/react/runtime/deno_integration_test.exs
new file mode 100644
index 0000000..c41ae01
--- /dev/null
+++ b/test/phoenix/react/runtime/deno_integration_test.exs
@@ -0,0 +1,85 @@
+defmodule Phoenix.React.Runtime.DenoIntegrationTest do
+ use ExUnit.Case, async: false
+
+ alias Phoenix.React.Runtime.Deno
+
+ describe "integration tests" do
+ @describetag :integration
+
+ test "config returns proper structure" do
+ config = Deno.config()
+
+ assert is_list(config)
+ assert Keyword.has_key?(config, :cd)
+ assert Keyword.has_key?(config, :cmd)
+ assert Keyword.has_key?(config, :server_js)
+ assert Keyword.has_key?(config, :port)
+ assert Keyword.has_key?(config, :env)
+
+ # Test default values
+ assert is_binary(config[:cd])
+ assert is_binary(config[:cmd]) or is_nil(config[:cmd])
+ assert is_binary(config[:server_js])
+ assert is_integer(config[:port])
+ assert config[:port] > 0
+ assert config[:env] in [:dev, :prod]
+ end
+
+ test "config respects application environment" do
+ custom_config = [
+ cmd: "/test/deno",
+ server_js: "/test/server.js",
+ port: 9999,
+ env: :prod,
+ cd: "/test/cd"
+ ]
+
+ Application.put_env(:phoenix_react_server, Deno, custom_config)
+
+ try do
+ config = Deno.config()
+ assert config[:cmd] == "/test/deno"
+ assert config[:server_js] == "/test/server.js"
+ assert config[:port] == 9999
+ assert config[:env] == :prod
+ assert config[:cd] == "/test/cd"
+ after
+ Application.delete_env(:phoenix_react_server, Deno)
+ end
+ end
+
+ test "get_rendered_component handles all render methods" do
+ state = %Phoenix.React.Runtime{
+ component_base: "/tmp/components",
+ render_timeout: 5000,
+ server_js: "/tmp/server.js",
+ cd: "/tmp",
+ runtime_port: nil
+ }
+
+ # Test all render methods return error when server is not running
+ methods = [:render_to_string, :render_to_static_markup, :render_to_readable_stream]
+
+ for method <- methods do
+ result = Deno.get_rendered_component(method, "test_component", %{}, state)
+ assert match?({:error, _}, result)
+ end
+ end
+
+ test "runtime state structure is valid" do
+ state = %Phoenix.React.Runtime{
+ component_base: "/test/components",
+ render_timeout: 30000,
+ server_js: "/test/server.js",
+ cd: "/test",
+ runtime_port: nil
+ }
+
+ assert state.component_base == "/test/components"
+ assert state.render_timeout == 30000
+ assert state.server_js == "/test/server.js"
+ assert state.cd == "/test"
+ assert state.runtime_port == nil
+ end
+ end
+end
diff --git a/test/phoenix/react/runtime/deno_test.exs b/test/phoenix/react/runtime/deno_test.exs
new file mode 100644
index 0000000..ea06e21
--- /dev/null
+++ b/test/phoenix/react/runtime/deno_test.exs
@@ -0,0 +1,72 @@
+defmodule Phoenix.React.Runtime.DenoTest do
+ use ExUnit.Case, async: false
+
+ alias Phoenix.React.Runtime.Deno
+
+ describe "config/0" do
+ test "returns default configuration" do
+ config = Deno.config()
+
+ assert Keyword.keyword?(config)
+ assert Keyword.has_key?(config, :cd)
+ assert Keyword.has_key?(config, :cmd)
+ assert Keyword.has_key?(config, :server_js)
+ assert Keyword.has_key?(config, :port)
+ assert Keyword.has_key?(config, :env)
+ end
+
+ test "uses custom configuration when provided" do
+ Application.put_env(:phoenix_react_server, Deno,
+ cmd: "/custom/deno",
+ server_js: "/custom/server.js",
+ port: 9999,
+ env: :prod
+ )
+
+ try do
+ config = Deno.config()
+ assert config[:cmd] == "/custom/deno"
+ assert config[:server_js] == "/custom/server.js"
+ assert config[:port] == 9999
+ assert config[:env] == :prod
+ after
+ Application.delete_env(:phoenix_react_server, Deno)
+ end
+ end
+ end
+
+ describe "start/1" do
+ test "starts deno process with correct arguments" do
+ # This test would require a actual deno installation
+ # For now, we'll test the configuration part
+ _component_base = "/tmp/components"
+
+ # Mock the Port.open to avoid actually starting deno
+ # In a real test environment, you might want to use Mox or similar
+
+ # Test that the function exists and can be called
+ assert is_function(&Deno.start/1)
+ end
+ end
+
+ describe "get_rendered_component/4" do
+ test "returns error when server is not running" do
+ component = "test_component"
+ props = %{"test" => "value"}
+
+ state = %Phoenix.React.Runtime{
+ component_base: "/tmp/components",
+ render_timeout: 5000,
+ server_js: "/tmp/server.js",
+ cd: "/tmp",
+ runtime_port: nil
+ }
+
+ # This should fail since there's no server running
+ result = Deno.get_rendered_component(:render_to_string, component, props, state)
+
+ # The result should be an error tuple
+ assert match?({:error, _}, result)
+ end
+ end
+end
diff --git a/test/phoenix/react/runtime_integration_test.exs b/test/phoenix/react/runtime_integration_test.exs
new file mode 100644
index 0000000..e31d576
--- /dev/null
+++ b/test/phoenix/react/runtime_integration_test.exs
@@ -0,0 +1,230 @@
+defmodule Phoenix.React.RuntimeIntegrationTest do
+ use ExUnit.Case, async: false
+
+ alias Phoenix.React.Runtime.Bun
+ alias Phoenix.React.Runtime.Deno
+ alias Phoenix.React.Config
+
+ @moduletag :integration
+
+ setup do
+ # Clean up any existing runtimes before each test
+ on_exit(fn ->
+ # Give processes time to clean up
+ Process.sleep(100)
+ end)
+
+ :ok
+ end
+
+ describe "Bun Runtime Integration" do
+ @describetag :bun_runtime
+
+ test "configuration validation" do
+ # Test valid configuration
+ valid_config = [
+ cmd: "bun",
+ port: 5225,
+ env: :dev,
+ cd: File.cwd!()
+ ]
+
+ assert {:ok, config} = Config.runtime_config(:bun, Enum.into(valid_config, %{}))
+ assert config.cmd == "bun"
+ assert config.port == 5225
+ assert config.env == :dev
+
+ # Test invalid configuration
+ invalid_config = [
+ cmd: "bun",
+ # Invalid port
+ port: 70000,
+ env: :dev
+ ]
+
+ assert {:error, _} = Config.runtime_config(:bun, Enum.into(invalid_config, %{}))
+ end
+
+ test "runtime startup and shutdown" do
+ # Skip if bun is not available
+ unless System.find_executable("bun") do
+ flunk("Bun not available for integration testing")
+ end
+
+ # Try multiple times to find an available port
+ {_test_port, pid} =
+ Enum.reduce_while(1..5, nil, fn _attempt, _acc ->
+ test_port = 15225 + :rand.uniform(1000)
+
+ Application.put_env(:phoenix_react_server, Bun,
+ cmd: System.find_executable("bun"),
+ port: test_port,
+ env: :dev,
+ cd: File.cwd!()
+ )
+
+ # Start the runtime without name registration
+ case GenServer.start_link(Bun, component_base: "test/fixtures", render_timeout: 5000) do
+ {:ok, pid} ->
+ # Give it time to start
+ Process.sleep(2000)
+
+ if Process.alive?(pid) do
+ {:halt, {test_port, pid}}
+ else
+ # Process died, try another port
+ {:cont, nil}
+ end
+
+ {:error, _reason} ->
+ # Failed to start, try another port
+ {:cont, nil}
+ end
+ end)
+
+ # If we couldn't find a working port, fail the test
+ if pid == nil do
+ flunk("Could not start Bun runtime after 5 attempts")
+ end
+
+ # Verify it's running
+ assert Process.alive?(pid)
+
+ # Stop the runtime
+ GenServer.stop(pid, :normal)
+
+ # Verify it's stopped
+ refute Process.alive?(pid)
+ end
+ end
+
+ describe "Deno Runtime Integration" do
+ @describetag :deno_runtime
+ @describetag :skip_if_no_deno
+
+ test "configuration validation" do
+ # Test valid configuration
+ valid_config = %{
+ cmd: "deno",
+ port: 5226,
+ env: :dev,
+ write_dirs: ["/tmp"],
+ parent_check_interval: 5000
+ }
+
+ assert {:ok, config} = Config.runtime_config(:deno, valid_config)
+ assert config.cmd == "deno"
+ assert config.port == 5226
+ assert config.write_dirs == ["/tmp"]
+
+ # Test invalid configuration
+ invalid_config = %{
+ cmd: "deno",
+ # Invalid port
+ port: 70000,
+ env: :dev,
+ # Empty write_dirs
+ write_dirs: []
+ }
+
+ assert {:error, _} = Config.runtime_config(:deno, invalid_config)
+ end
+
+ @tag :skip_if_no_deno
+ test "runtime startup and shutdown" do
+ # Skip if deno is not available - this is handled by the setup below
+
+ # Configure test environment with unique port
+ test_port = 15227 + :rand.uniform(1000)
+
+ Application.put_env(:phoenix_react_server, Deno,
+ cmd: System.find_executable("deno"),
+ port: test_port,
+ env: :dev,
+ cd: File.cwd!(),
+ write_dirs: ["/tmp"],
+ parent_check_interval: 2000
+ )
+
+ # Start the runtime
+ {:ok, pid} = Deno.start_link(component_base: "test/fixtures", render_timeout: 5000)
+
+ # Give it time to start
+ Process.sleep(3000)
+
+ # Verify it's running
+ assert Process.alive?(pid)
+
+ # Stop the runtime
+ GenServer.stop(pid, :normal)
+
+ # Verify it's stopped
+ refute Process.alive?(pid)
+ end
+ end
+
+ describe "Common Functionality" do
+ test "security configuration validation" do
+ security_config = Config.security_config()
+
+ assert security_config.max_component_name_length == 100
+ assert is_struct(security_config.allowed_component_name_pattern, Regex)
+ assert security_config.max_request_size == 1_048_576
+ assert security_config.request_timeout_ms == 30000
+ end
+
+ test "file watcher configuration validation" do
+ watcher_config = Config.file_watcher_config()
+
+ assert watcher_config.throttle_ms == 3000
+ assert watcher_config.debounce_ms == 100
+ end
+
+ test "monitoring functionality" do
+ # Test monitoring functions don't crash
+ assert :ok = Phoenix.React.Monitoring.record_render("test", :render_to_string, 100, :ok)
+ assert :ok = Phoenix.React.Monitoring.record_runtime_startup("test", 5225)
+ assert :ok = Phoenix.React.Monitoring.record_runtime_shutdown("test", :normal)
+ assert :ok = Phoenix.React.Monitoring.record_file_change("/test/path", "changed")
+ assert :ok = Phoenix.React.Monitoring.record_build("test", 1000, :ok)
+
+ # Test measurement function
+ result =
+ Phoenix.React.Monitoring.measure("test_op", [:test], fn ->
+ Process.sleep(10)
+ :test_result
+ end)
+
+ assert result == :test_result
+
+ # Test runtime stats
+ stats = Phoenix.React.Monitoring.get_runtime_stats("test")
+ assert is_map(stats)
+ assert stats.runtime == "test"
+ end
+ end
+
+ describe "Error Handling" do
+ test "invalid component names are rejected" do
+ # This would be tested through the actual HTTP requests to the runtime servers
+ # For now, we test the validation logic
+ security_config = Config.security_config()
+ pattern = security_config.allowed_component_name_pattern
+
+ # Valid names
+ assert "valid_component" =~ pattern
+ assert "valid-component-123" =~ pattern
+
+ # Invalid names
+ refute "../../../etc/passwd" =~ pattern
+ refute "component