Goss

Goss is a declarative system validation framework that verifies server state by comparing live system attributes against YAML specifications. It checks the state of packages, ports, services, files, users, processes, DNS records, kernel parameters, mounts, network interfaces, and HTTP endpoints, reporting pass or fail for each condition.

The tool distinguishes itself through several automation capabilities. It can scan a running system to automatically generate YAML baseline files that capture current resource configurations, eliminating the need to write tests from scratch. A retry-with-timeout validation loop repeatedly executes the full test suite until all checks pass or a configurable timeout expires, enabling asynchronous provisioning validation and readiness polling. Test suites can be parameterized using Jinja templates and variable files, allowing the same validation logic to be reused across different environments without duplicating test definitions.

Goss supports cross-platform execution and outputs validation results in multiple formats including JSON, JUnit, Nagios, and Prometheus for integration with different monitoring and reporting toolchains. It can serve validation results as a live HTTP health endpoint that external monitoring systems and load balancers can poll in real time. The tool also provides a JSON Schema for test files to enable inline documentation, autocompletion, and static analysis in IDEs.

Installation is handled through a single shell command that downloads the binary and optional Docker helper script from GitHub releases.

Features

Declarative Server Validators - Verifying infrastructure state by comparing live system attributes against YAML specifications for configuration testing and compliance checks.
Server State Validators - Defines system state expectations as YAML files compared against live server attributes to determine pass or fail.
YAML-Defined Agents - Write infrastructure validation rules as structured YAML files, making tests human-readable and version-controllable.
Declarative Test Runners - Runs defined YAML tests against a target server and outputs pass or fail results for each check.
State-Based Wait Loops - Polls the system until all defined tests pass or a timeout is reached.
Configuration State Validation - Compares current system properties such as packages, services, and ports against a YAML specification to verify configuration.
Resource State Validation - Checks properties of files, packages, services, ports, and other OS resources against expected values defined in a YAML file.
State Validators - Runs declarative YAML tests against system resources like packages, services, and ports to verify server configuration.
YAML Variable Files - Apply variable substitution from a separate YAML file to the test suite, enabling environment-specific configurations.
System Readiness Pollers - Polls the system until all defined tests pass, allowing orchestration scripts to block until a server is fully configured.
Infrastructure Validation Tools - Verifies server state by comparing current system attributes against a declarative YAML specification.
System Resource Checkers - Implements separate checkers for each system resource type like packages, ports, and services for extensible validation.
Multi-Resource State Validators - Checks the state of packages, files, ports, services, users, groups, commands, DNS, mounts, network interfaces, HTTP endpoints, and kernel parameters.
Infrastructure State Baselines - Scans a running system to automatically produce YAML test files capturing current resource configurations as validation baselines.
State Validators - Runs a set of YAML-defined checks against the running system and reports whether each condition passes or fails.
YAML-Based Health Check Executors - Executes a set of predefined YAML tests from the command line and reports pass or fail results for each check.
System Resource Monitors - Tracks live system-level resource consumption for processes, files, and sockets.
Automated Test Execution - Executes a set of predefined YAML-based tests against server resources to verify their current state.
Retry Until Success - Repeatedly executes the full test suite until all checks pass or a configurable timeout expires for asynchronous provisioning validation.
Resource Existence Validation - Verifies that a system resource such as a package, file, port, service, user, or process exists and meets specified conditions.
Declarative Server Configuration Validators - Runs a generated YAML test suite against the live system and reports which checks pass or fail, with support for retries until a desired state is reached.
Automated Infrastructure Testing - Run server validation tests that retry until passing, integrate into pipelines, or expose as health endpoints.
File System Property Assertions - Checks that a file or directory exists, has the correct permissions, owner, and content.
Infrastructure Test Generators - Scan the current live system and produce a YAML test file that captures the state of selected resources, so users do not write tests from scratch.
CLI Test Runners - Executes a suite of declarative YAML tests against the current system state and reports pass or fail results.
Declarative Infrastructure Test Suites - Write infrastructure tests as a YAML file that declares expected values for system properties like packages, services, and ports.
Declarative Test Suites - Define a collection of system validation checks in a declarative YAML file for repeatable execution.
Infrastructure State Validators - Runs declarative YAML test suites against live servers to verify packages, ports, services, and files match expected state.
System State Assertions - Validates packages, files, ports, services, users, processes, DNS, and kernel parameters against expected states.
Template Variable Validation - Apply template variables from a separate YAML file to the test suite, enabling environment-specific configurations.
Test Suite Execution - Executes a set of predefined system checks against live server attributes and reports pass or fail status.
Parameterized Test Suites - Uses Jinja templates and variable files to parameterize test suites for reuse across environments.
Environment-Specific Test Suites - Provides Jinja template and variable file support to reuse test suites across different server environments.
System Property Validators - Checks real-time values of system properties such as packages, services, ports, and files against expected states defined in YAML.
System Package Version Audits - Verifies that installed system packages match a declared version or are absent from the system.
Infrastructure State Captures - Scans the current server configuration and produces a YAML test suite capturing resource states.
Attribute Coverage Verifiers - Verifies that files, packages, services, and other OS resources have the expected properties and values.
CSV Output Formats - Formats validation results as JSON, JUnit, Prometheus, Nagios, or other structured outputs.
Installed Package Queries - Checks that specified packages are present, absent, or at a particular version on the system.
Process Status Assertions - Asserts that a named process is running with the expected user, group, and resource limits.
Validation Result Renderers - Outputs validation results in JSON, JUnit, Nagios, and Prometheus formats for monitoring toolchain integration.
Connectivity Verifiers - Confirms that network services and endpoints respond as expected using declarative test definitions.
DNS Record Verification - Validates the existence and configuration of specific DNS records to confirm server capabilities.
Reachability Validators - Checks that a remote TCP address or HTTP URL is reachable and responds as expected.
Port Reachability Testing - Verifies that a host and port are reachable and optionally checks TLS certificate details.
Listening Port Inspections - Confirms that specified TCP or UDP ports are listening on the expected interfaces.
Kernel Parameter Assertions - Reads a kernel parameter from /proc/sys and asserts its value matches the expected setting.
Variable Templates - Inject external variable values into YAML test templates, allowing the same test suite to be reused across different environments.
File Property Verifiers - Checks that files and directories exist with the correct owner, group, mode, size, and content hash.
System State Baseline Generators - Scans a running server and produces a YAML file describing its current state for use as a validation baseline.
Runtime Variable Injections - Injects variable values into test definitions at runtime, enabling the same test suite to be reused across different environments.
Infrastructure Test Baselines - Scans a running server to automatically produce a YAML test suite capturing current resource states as a validation baseline.
System Metric Threshold Checks - Reads CPU, memory, disk, and network metrics and compares them against defined thresholds.
Protocol-Compatible Health Endpoints - Exposes validation results as a live HTTP endpoint so monitoring systems and load balancers can poll server health status.
Health Monitoring Endpoints - Exposes validation results as a live HTTP endpoint for integration with monitoring and health-check systems.
HTTP Health Probes - Exposes validation results as a live HTTP endpoint for real-time health checks and monitoring system integration.
HTTP Endpoint Probes - Sends HTTP requests and validates response status, headers, and body content against expected values.
API Endpoint Testing - Sends HTTP requests to endpoints and validates response codes, headers, and body content against expected values.
Pattern Matching Boolean Tests - Uses advanced matchers and patterns within test definitions to express flexible, non-literal conditions for resource state checks.
Test Result Reporters - Outputs validation results in JSON, JUnit, Nagios, Prometheus, and other formats for monitoring toolchain integration.
File Property Assertions - Checks file existence, permissions, ownership, size, and content against expected values.
Cross-Platform Test Execution - Execute the same declarative infrastructure tests across different operating systems and environments without modification.
Environment-Parameterized Suites - Uses Jinja templates and variable files to parameterize test suites for reuse across different environments.
Test File Imports - Include another test file so tests can be split across multiple files and composed together.
Process Presence Assertions - Confirms that a named process is present and running on the system.
Testing Frameworks - Fast, YAML-based validation tool for container configurations.

aelsabbahy/goss

5,908View on GitHub

Goss is an infrastructure validation tool and testing framework used to verify that a server's current state matches a desired configuration. It compares live system output against YAML or JSON specifications to validate components such as packages, services, users, and network ports. The tool enables the automated generation of test specifications by capturing the existing state of a system. It supports diverse deployment environments through the use of dynamic templates and variable files. Beyond point-in-time validation, the framework can execute retrying tests that poll for state converg

sbt/sbt

4,929View on GitHub

Sbt is a JVM build tool and dependency management system designed for Scala and Java. It functions as a multi-project build orchestrator that manages the compilation of source code, resolves external libraries from remote repositories, and packages binaries for distribution. The project is distinguished by its interactive build system, which provides a read-eval-print loop for real-time state inspection and task execution. It utilizes a dependency-graph based execution model to process tasks and maintains a type-safe key-value store for dynamic build configuration. Its capabilities cover JVM

remix-project-org/remix-project

3,003View on GitHub

Remix is a comprehensive blockchain development environment and Ethereum smart contract IDE. It provides a complete workspace for writing, compiling, deploying, and debugging smart contracts across simulated and public blockchain networks. The project distinguishes itself as a specialized toolchain for EVM debugging and analysis, offering opcode-level transaction stepping and state memory analysis. It also includes a dedicated zero-knowledge proof toolchain for compiling ZK circuits and generating cryptographic proofs, alongside an AI-powered coding assistant for code generation and explanati

substack/tape

5,800View on GitHub

Tape is a JavaScript testing framework and assertion library that serves as a test runner for Node.js and browser environments. It implements the Test Anything Protocol to provide a standardized, machine-readable format for test results. The project functions as a cross-environment test harness, allowing the same test suites to be executed across both server-side and client-side environments while maintaining a consistent output protocol. Its capabilities include validating value equality and truthiness, verifying exception handling, and coordinating asynchronous workflows. The framework als

goss-orggoss

Features