blokctl 1.2.0 → 1.4.0

package/dist/scaffold-repo/sdks/ruby/test/logging/logger_test.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class LoggerTest < Minitest::Test
+  def test_level_filtering_info
+    logger = Blok::Logging::Logger.new(:info)
+    logger.debug("hidden")
+    logger.info("visible1")
+    logger.warn("visible2")
+    logger.error("visible3")
+
+    assert_equal 3, logger.entries.length
+  end
+
+  def test_level_filtering_debug
+    logger = Blok::Logging::Logger.new(:debug)
+    logger.debug("visible")
+    logger.info("visible")
+
+    assert_equal 2, logger.entries.length
+  end
+
+  def test_level_filtering_error
+    logger = Blok::Logging::Logger.new(:error)
+    logger.debug("hidden")
+    logger.info("hidden")
+    logger.warn("hidden")
+    logger.error("visible")
+
+    assert_equal 1, logger.entries.length
+  end
+
+  def test_entries_contain_correct_levels
+    logger = Blok::Logging::Logger.new(:debug)
+    logger.debug("d")
+    logger.info("i")
+    logger.warn("w")
+    logger.error("e")
+
+    levels = logger.entries.map(&:level)
+    assert_equal %i[debug info warn error], levels
+  end
+
+  def test_entries_contain_messages
+    logger = Blok::Logging::Logger.new(:debug)
+    logger.info("hello world")
+
+    entries = logger.entries
+    assert_equal 1, entries.length
+    assert_equal "hello world", entries[0].message
+  end
+
+  def test_entries_contain_timestamp
+    logger = Blok::Logging::Logger.new(:debug)
+    logger.info("test")
+
+    entry = logger.entries.first
+    assert entry.timestamp
+    assert_match(/\d{4}-\d{2}-\d{2}/, entry.timestamp)
+  end
+
+  def test_info_with_fields
+    logger = Blok::Logging::Logger.new(:debug)
+    logger.info("test", fields: { "key" => "value" })
+
+    entry = logger.entries.first
+    assert_equal({ "key" => "value" }, entry.fields)
+  end
+
+  def test_lines_format
+    logger = Blok::Logging::Logger.new(:debug)
+    logger.info("hello")
+    logger.error("oops")
+
+    lines = logger.lines
+    assert_equal 2, lines.length
+    assert_match(/\[INFO\]/, lines[0])
+    assert_match(/hello/, lines[0])
+    assert_match(/\[ERROR\]/, lines[1])
+    assert_match(/oops/, lines[1])
+  end
+
+  def test_lines_with_fields
+    logger = Blok::Logging::Logger.new(:debug)
+    logger.info("test", fields: { "x" => 1 })
+
+    line = logger.lines.first
+    assert_match(/\[INFO\]/, line)
+    assert_match(/"x":1/, line.gsub(" ", ""))
+  end
+
+  def test_clear
+    logger = Blok::Logging::Logger.new(:debug)
+    logger.info("test")
+    assert_equal 1, logger.entries.length
+
+    logger.clear
+    assert_equal 0, logger.entries.length
+  end
+
+  def test_entries_returns_copy
+    logger = Blok::Logging::Logger.new(:debug)
+    logger.info("test")
+
+    entries = logger.entries
+    entries.clear
+
+    # Original should be unaffected
+    assert_equal 1, logger.entries.length
+  end
+
+  def test_thread_safety
+    logger = Blok::Logging::Logger.new(:debug)
+
+    threads = 10.times.map do |i|
+      Thread.new { 100.times { logger.info("thread-#{i}") } }
+    end
+    threads.each(&:join)
+
+    assert_equal 1000, logger.entries.length
+  end
+
+  def test_log_entry_to_hash
+    entry = Blok::Logging::LogEntry.new(
+      level: :info,
+      message: "test message",
+      fields: { "key" => "val" }
+    )
+
+    hash = entry.to_hash
+    assert_equal "INFO", hash["level"]
+    assert_equal "test message", hash["message"]
+    assert hash["timestamp"]
+    assert_equal({ "key" => "val" }, hash["fields"])
+  end
+
+  def test_log_level_parse
+    assert_equal :debug, Blok::Logging::LogLevel.parse("DEBUG")
+    assert_equal :info, Blok::Logging::LogLevel.parse("INFO")
+    assert_equal :warn, Blok::Logging::LogLevel.parse("WARN")
+    assert_equal :error, Blok::Logging::LogLevel.parse("ERROR")
+    assert_equal :info, Blok::Logging::LogLevel.parse("unknown")
+    assert_equal :debug, Blok::Logging::LogLevel.parse("debug")
+  end
+
+  def test_log_level_priority
+    assert Blok::Logging::LogLevel.priority(:debug) <
+           Blok::Logging::LogLevel.priority(:info)
+    assert Blok::Logging::LogLevel.priority(:info) <
+           Blok::Logging::LogLevel.priority(:warn)
+    assert Blok::Logging::LogLevel.priority(:warn) <
+           Blok::Logging::LogLevel.priority(:error)
+  end
+end

package/dist/scaffold-repo/sdks/ruby/test/node/node_registry_test.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+# Simple test node that returns configured data.
+class TestNode < Blok::Node::NodeHandler
+  def initialize(data = { "ok" => true })
+    super()
+    @data = data
+  end
+
+  def execute(_ctx, _config)
+    @data
+  end
+end
+
+# Node that raises an error.
+class ErrorNode < Blok::Node::NodeHandler
+  def execute(_ctx, _config)
+    raise Blok::Errors::NodeError.validation("bad input")
+  end
+end
+
+class NodeRegistryTest < Minitest::Test
+  def setup
+    @registry = Blok::Node::NodeRegistry.new("1.0.0")
+  end
+
+  def test_register_and_get
+    @registry.register("test", TestNode.new)
+
+    assert_instance_of TestNode, @registry.get("test")
+    assert_nil @registry.get("missing")
+  end
+
+  def test_node_names
+    @registry.register("beta", TestNode.new)
+    @registry.register("alpha", TestNode.new)
+
+    names = @registry.node_names
+    assert_equal %w[alpha beta], names
+  end
+
+  def test_execute_success
+    @registry.register("test", TestNode.new({ "msg" => "hello" }))
+
+    ctx     = Blok::Testing::MockContext.new.build
+    request = Blok::Types::ExecutionRequest.new(
+      node:    Blok::Types::NodeConfig.new(name: "test"),
+      context: ctx
+    )
+    result = @registry.execute(request)
+
+    assert result.success
+    assert_equal "hello", result.data["msg"]
+    assert result.metrics
+    assert result.metrics.duration_ms >= 0
+  end
+
+  def test_execute_not_found
+    ctx     = Blok::Testing::MockContext.new.build
+    request = Blok::Types::ExecutionRequest.new(
+      node:    Blok::Types::NodeConfig.new(name: "missing"),
+      context: ctx
+    )
+    result = @registry.execute(request)
+
+    refute result.success
+    assert_match(/not found/, result.errors["message"])
+  end
+
+  def test_execute_error_handling
+    @registry.register("error", ErrorNode.new)
+
+    ctx     = Blok::Testing::MockContext.new.build
+    request = Blok::Types::ExecutionRequest.new(
+      node:    Blok::Types::NodeConfig.new(name: "error"),
+      context: ctx
+    )
+    result = @registry.execute(request)
+
+    refute result.success
+    assert result.metrics
+    assert result.metrics.duration_ms >= 0
+  end
+
+  def test_health
+    @registry.register("a", TestNode.new)
+    @registry.register("b", TestNode.new)
+
+    health = @registry.health
+
+    assert_equal "healthy", health.status
+    assert_equal "1.0.0", health.version
+    assert_equal 2, health.nodes_loaded.length
+    assert_includes health.nodes_loaded, "a"
+    assert_includes health.nodes_loaded, "b"
+  end
+
+  def test_middleware_applied
+    log_entries = []
+    middleware = Class.new(Blok::Middleware::Middleware) do
+      define_method(:initialize) do |entries|
+        super()
+        @entries = entries
+      end
+
+      define_method(:wrap) do |handler|
+        entries = @entries
+        ->(ctx, config) {
+          entries << "before"
+          result = handler.call(ctx, config)
+          entries << "after"
+          result
+        }
+      end
+    end
+
+    @registry.use(middleware.new(log_entries))
+    @registry.register("test", TestNode.new)
+
+    ctx     = Blok::Testing::MockContext.new.build
+    request = Blok::Types::ExecutionRequest.new(
+      node:    Blok::Types::NodeConfig.new(name: "test"),
+      context: ctx
+    )
+    result = @registry.execute(request)
+
+    assert result.success
+    assert_equal %w[before after], log_entries
+  end
+end

package/dist/scaffold-repo/sdks/ruby/test/node/typed_node_test.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "json"
+# Require the pure-Ruby contract files directly (avoids loading the
+# protobuf/grpc stack, so this runs without the gRPC gems installed).
+require_relative "../../lib/blok/node/typed_node"
+
+class TypedNodeTest < Minitest::Test
+  class SearchNode < Blok::Node::TypedNode
+    node_name "@acme/search"
+    description "Full-text search"
+
+    input do
+      field :query, :string, required: true
+      field :limit, :integer, default: 10
+    end
+
+    output do
+      field :results, :array
+      field :count, :integer
+    end
+
+    def run(_ctx, input)
+      rows = [input[:query]] * input[:limit]
+      { "results" => rows, "count" => rows.size }
+    end
+  end
+
+  def test_validates_input_and_runs
+    out = SearchNode.new.execute(nil, { "query" => "ada", "limit" => 2 })
+    assert_equal 2, out["count"]
+    assert_equal %w[ada ada], out["results"]
+  end
+
+  def test_applies_default_values
+    out = SearchNode.new.execute(nil, { "query" => "x" })
+    assert_equal 10, out["count"]
+  end
+
+  def test_missing_required_field_raises_structured_blok_error
+    err = assert_raises(Blok::Errors::BlokError) do
+      SearchNode.new.execute(nil, { "limit" => 3 })
+    end
+    assert_equal 400, err.http_status
+    assert_equal "NODE_INPUT_VALIDATION", err.code
+    assert_equal "@acme/search", err.node
+  end
+
+  def test_wrong_type_raises_structured_blok_error
+    err = assert_raises(Blok::Errors::BlokError) do
+      SearchNode.new.execute(nil, { "query" => 123 }) # Integer where :string declared
+    end
+    assert_equal 400, err.http_status
+  end
+
+  def test_reflection_schemas_and_description
+    reflection = SearchNode.new.reflect
+    assert_equal "Full-text search", reflection[:description]
+
+    schema = JSON.parse(reflection[:input_schema_json])
+    assert_equal "object", schema["type"]
+    assert schema["properties"].key?("query")
+    assert_equal ["query"], schema["required"]
+    refute_nil reflection[:output_schema_json]
+  end
+end

package/dist/scaffold-repo/sdks/ruby/test/test_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "blok"

package/dist/scaffold-repo/sdks/ruby/test/testing/mock_context_test.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class MockContextTest < Minitest::Test
+  def test_default_values
+    ctx = Blok::Testing::MockContext.new.build
+
+    assert_equal "test-execution-id", ctx.id
+    assert_equal "test-workflow", ctx.workflow_name
+    assert_equal "/workflows/test", ctx.workflow_path
+    assert_equal "POST", ctx.request.method
+    assert_equal "/test", ctx.request.url
+    assert_equal({}, ctx.vars)
+    assert_equal({}, ctx.env)
+  end
+
+  def test_with_id
+    ctx = Blok::Testing::MockContext.new
+      .with_id("custom-id")
+      .build
+
+    assert_equal "custom-id", ctx.id
+  end
+
+  def test_with_workflow
+    ctx = Blok::Testing::MockContext.new
+      .with_workflow("my-workflow", "/wf/my-workflow")
+      .build
+
+    assert_equal "my-workflow", ctx.workflow_name
+    assert_equal "/wf/my-workflow", ctx.workflow_path
+  end
+
+  def test_with_workflow_default_path
+    ctx = Blok::Testing::MockContext.new
+      .with_workflow("auth")
+      .build
+
+    assert_equal "auth", ctx.workflow_name
+    assert_equal "/workflows/auth", ctx.workflow_path
+  end
+
+  def test_with_body
+    ctx = Blok::Testing::MockContext.new
+      .with_body({ "name" => "John", "age" => 30 })
+      .build
+
+    assert_equal "John", ctx.request.body["name"]
+    assert_equal 30, ctx.request.body["age"]
+  end
+
+  def test_with_headers
+    ctx = Blok::Testing::MockContext.new
+      .with_headers({ "Authorization" => "Bearer token" })
+      .build
+
+    assert_equal "Bearer token", ctx.request.headers["Authorization"]
+  end
+
+  def test_with_method
+    ctx = Blok::Testing::MockContext.new
+      .with_method("GET")
+      .build
+
+    assert_equal "GET", ctx.request.method
+  end
+
+  def test_with_var
+    ctx = Blok::Testing::MockContext.new
+      .with_var("key1", "value1")
+      .with_var("key2", 42)
+      .build
+
+    assert_equal "value1", ctx.vars["key1"]
+    assert_equal 42, ctx.vars["key2"]
+  end
+
+  def test_with_env
+    ctx = Blok::Testing::MockContext.new
+      .with_env("API_KEY", "secret123")
+      .with_env("DEBUG", "true")
+      .build
+
+    assert_equal "secret123", ctx.env["API_KEY"]
+    assert_equal "true", ctx.env["DEBUG"]
+  end
+
+  def test_fluent_chaining
+    ctx = Blok::Testing::MockContext.new
+      .with_id("chain-test")
+      .with_workflow("wf")
+      .with_body({ "x" => 1 })
+      .with_headers({ "H" => "V" })
+      .with_var("a", "b")
+      .with_env("E", "F")
+      .build
+
+    assert_equal "chain-test", ctx.id
+    assert_equal "wf", ctx.workflow_name
+    assert_equal 1, ctx.request.body["x"]
+    assert_equal "V", ctx.request.headers["H"]
+    assert_equal "b", ctx.vars["a"]
+    assert_equal "F", ctx.env["E"]
+  end
+
+  def test_context_set_and_get_var
+    ctx = Blok::Testing::MockContext.new.build
+
+    ctx.set_var("greeting", "Hello!")
+    assert_equal "Hello!", ctx.get_var("greeting")
+    assert_equal "Hello!", ctx.get_var_str("greeting")
+    assert_nil ctx.get_var("missing")
+    assert_nil ctx.get_var_str("missing")
+  end
+
+  def test_context_get_var_str_non_string
+    ctx = Blok::Testing::MockContext.new
+      .with_var("count", 42)
+      .build
+
+    assert_equal 42, ctx.get_var("count")
+    assert_nil ctx.get_var_str("count")
+  end
+
+  def test_context_to_hash_roundtrip
+    ctx = Blok::Testing::MockContext.new
+      .with_id("roundtrip")
+      .with_body({ "key" => "val" })
+      .with_var("v", "1")
+      .build
+
+    hash     = ctx.to_hash
+    restored = Blok::Types::Context.from_hash(hash)
+
+    assert_equal "roundtrip", restored.id
+    assert_equal "val", restored.request.body["key"]
+    assert_equal "1", restored.vars["v"]
+  end
+
+  def test_request_body_str
+    ctx = Blok::Testing::MockContext.new
+      .with_body({ "name" => "Alice", "count" => 5 })
+      .build
+
+    assert_equal "Alice", ctx.request.body_str("name")
+    assert_nil ctx.request.body_str("count")  # Not a string
+    assert_nil ctx.request.body_str("missing")
+  end
+end

package/dist/scaffold-repo/sdks/ruby/test/types/execution_result_test.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative "../test_helper"
+
+class ExecutionResultTest < Minitest::Test
+  def test_success_factory
+    result = Blok::Types::ExecutionResult.success({ "msg" => "hello" })
+
+    assert result.success
+    assert_equal({ "msg" => "hello" }, result.data)
+    assert_nil result.errors
+    assert_nil result.logs
+    assert_nil result.metrics
+  end
+
+  def test_success_with_metrics_factory
+    metrics = Blok::Types::ExecutionMetrics.new(duration_ms: 12.5)
+    result  = Blok::Types::ExecutionResult.success_with_metrics({ "ok" => true }, metrics)
+
+    assert result.success
+    assert_equal({ "ok" => true }, result.data)
+    assert_equal 12.5, result.metrics.duration_ms
+  end
+
+  def test_error_factory
+    result = Blok::Types::ExecutionResult.error("something broke")
+
+    refute result.success
+    assert_nil result.data
+    assert_equal "something broke", result.errors["message"]
+  end
+
+  def test_error_with_details_factory
+    result = Blok::Types::ExecutionResult.error_with_details(
+      "validation failed",
+      { "field" => "name" }
+    )
+
+    refute result.success
+    assert_equal "validation failed", result.errors["message"]
+    assert_equal({ "field" => "name" }, result.errors["details"])
+  end
+
+  def test_with_logs
+    result = Blok::Types::ExecutionResult.success({ "x" => 1 })
+    result.with_logs(["line1", "line2"])
+
+    assert_equal ["line1", "line2"], result.logs
+  end
+
+  def test_with_metrics
+    result  = Blok::Types::ExecutionResult.success({})
+    metrics = Blok::Types::ExecutionMetrics.new(duration_ms: 5.0, cpu_ms: 3.0)
+    result.with_metrics(metrics)
+
+    assert_equal 5.0, result.metrics.duration_ms
+    assert_equal 3.0, result.metrics.cpu_ms
+  end
+
+  def test_to_hash_success
+    result = Blok::Types::ExecutionResult.success({ "key" => "val" })
+    hash   = result.to_hash
+
+    assert_equal true, hash["success"]
+    assert_equal({ "key" => "val" }, hash["data"])
+    refute hash.key?("errors")
+    refute hash.key?("logs")
+    refute hash.key?("metrics")
+  end
+
+  def test_to_hash_with_all_fields
+    metrics = Blok::Types::ExecutionMetrics.new(duration_ms: 10.0)
+    result  = Blok::Types::ExecutionResult.success({ "a" => 1 })
+    result.with_logs(["log1"])
+    result.with_metrics(metrics)
+
+    hash = result.to_hash
+
+    assert_equal true, hash["success"]
+    assert_equal ["log1"], hash["logs"]
+    assert_equal({ "duration_ms" => 10.0 }, hash["metrics"])
+  end
+
+  def test_to_hash_error
+    result = Blok::Types::ExecutionResult.error("fail")
+    hash   = result.to_hash
+
+    assert_equal false, hash["success"]
+    assert_nil hash["data"]
+    assert_equal "fail", hash["errors"]["message"]
+  end
+
+  def test_from_hash_roundtrip
+    original = Blok::Types::ExecutionResult.success_with_metrics(
+      { "msg" => "hi" },
+      Blok::Types::ExecutionMetrics.new(duration_ms: 7.5)
+    )
+    original.with_logs(["entry"])
+
+    json     = JSON.generate(original.to_hash)
+    restored = Blok::Types::ExecutionResult.from_hash(JSON.parse(json))
+
+    assert restored.success
+    assert_equal "hi", restored.data["msg"]
+    assert_equal 7.5, restored.metrics.duration_ms
+  end
+
+  def test_metrics_to_hash_omits_nil
+    metrics = Blok::Types::ExecutionMetrics.new(duration_ms: 5.0)
+    hash    = metrics.to_hash
+
+    assert_equal({ "duration_ms" => 5.0 }, hash)
+    refute hash.key?("cpu_ms")
+    refute hash.key?("memory_bytes")
+  end
+
+  def test_metrics_to_hash_all_fields
+    metrics = Blok::Types::ExecutionMetrics.new(
+      duration_ms: 10.0,
+      cpu_ms: 8.0,
+      memory_bytes: 1024
+    )
+    hash = metrics.to_hash
+
+    assert_equal 10.0, hash["duration_ms"]
+    assert_equal 8.0, hash["cpu_ms"]
+    assert_equal 1024, hash["memory_bytes"]
+  end
+end