autobot: Skill for Claude Code

Testing Standards

AAA Pattern

Structure all tests with Arrange-Act-Assert and require the spec helper:

require "../spec_helper"

describe "MyFeature" do
  it "does something expected" do
    # Arrange
    tool = Autobot::Tools::MyTool.new
    params = {"key" => JSON::Any.new("value")}
    
    # Act
    result = tool.execute(params)
    
    # Assert
    result.success?.should be_true
    result.content.should contain("expected")
  end
end

Test File Organization

Mirror source structure:

spec/
├── autobot/
│   ├── providers/
│   │   ├── http_provider_spec.cr
│   │   └── registry_spec.cr
│   ├── tools/
│   │   ├── web_spec.cr
│   │   └── exec_spec.cr
│   └── config/
│       └── schema_spec.cr
├── spec_helper.cr
└── security_spec.cr

Running Tests

# Run all tests
crystal spec

# Run specific file
crystal spec spec/autobot/tools/web_spec.cr

# Run specific test by line number
crystal spec spec/autobot/tools/web_spec.cr:42

# Run with verbose output
crystal spec -v

# Run with color (default)
crystal spec --color

Mocking External Services

HTTP Provider Mocking:

class MockHttpProvider < Autobot::Providers::HttpProvider
  property responses = [] of HTTP::Client::Response
  property call_count = 0

  def post(path : String, body : Hash) : HTTP::Client::Response
    @call_count += 1
    responses.shift? || HTTP::Client::Response.new(500, body: "{}").tap { |r| r.consume_body_io }
  end
end

Tool Execution Mocking:

# Use dependency injection or monkey-patch for tests
class TestableExecTool < Autobot::Tools::ExecTool
  property captured_commands = [] of String

  def execute_system_command(cmd)
    @captured_commands << cmd
    {output: "mock output", exit_code: 0}
  end
end

Testing Error Conditions

Always test error paths:

it "handles missing parameters" do
  tool = Autobot::Tools::MyTool.new
  result = tool.execute({} of String => JSON::Any)
  
  result.error?.should be_true
  result.content.should contain("missing")
end

it "handles rate limiting" do
  limiter = Autobot::Tools::RateLimiter.new(
    per_tool_limits: {"exec" => Autobot::Tools::RateLimiter::Limit.new(
      max_calls: 1,
      window_seconds: 60
    )}
  )
  
  limiter.record_call("exec", "session")
  error = limiter.check_limit("exec", "session")
  
  error.should_not be_nil
  error.should contain("max 1 calls")
end