go-cli-test-support 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d1a356d0fbada22cc722ad5516793aa5fd28f1cd08b20db78645f4f0da59777c
+  data.tar.gz: 4a2bafbeba9d24756100a1d0ee29471a8b5d195f08586f1e7bf471c3fd66029b
+SHA512:
+  metadata.gz: 69609759b14e5a041425ebea37156b14de6cd35ca1817959b8b9af65aea6d082c51f92f956a9a3fa5a53dff1ed2017e714129ed02b9ae5390e315415a4ca8ed3
+  data.tar.gz: 2c0dcb65e293b3298e501caa8b8fb688ab2d3c9bbce8d110deb6642d6617dc45f327d85b9da082f276aaaeeb658f2aaedc955a846dd8c428c14517f8b1399b6d

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2026-03-02
+
+### Added
+- **Error handling enhancements**: Validates project directory and `go.mod` existence
+- **Timeout support**: Configurable timeout for command execution (default: 30s)
+- **Debug mode**: Detailed logging via `debug` accessor
+- **Build flags**: Custom Go build flags support (e.g., `-ldflags`, `-tags`)
+
+### Changed
+- `setup_go_test` now accepts `build_flags` parameter
+- `exec` now accepts `timeout` parameter
+- Better error messages with `ArgumentError` for invalid inputs
+
+### Fixed
+- None (all changes are additions)
+
+## [0.1.0] - 2026-03-02
+
+### Added
+- Initial release
+- `setup_go_test` method for automatic Go binary compilation
+- `teardown_go_test` method for cleanup
+- `exec` method for running compiled binaries
+- Automatic binary name detection from `go.mod`
+- Automatic `cmd/` directory detection
+- Environment isolation with custom `$HOME`
+- Support for stdin input
+- Access to stdout, stderr, and exit_code

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,324 @@
+# go-cli-test-support
+
+**A Ruby gem that compiles Go CLI applications to binaries and enables testing with RSpec using a DSL-like syntax for command-line arguments.**
+
+RSpec test helper for Go CLI applications that simplifies testing by handling compilation, execution, and environment isolation automatically.
+
+## What is this?
+
+This library is a helper for **testing Go CLI applications with RSpec**.
+
+While you would normally use Go's `testing` package to test Go applications, this library allows you to:
+
+1. **Compile your Go app to a binary**
+2. **Write command-line arguments using RSpec's DSL-like syntax**
+3. **Easily capture stdout/stderr/exit_code**
+4. **Completely isolate the environment** (each test gets its own `$HOME`)
+
+```ruby
+# You can write tests like this
+exec('add', '10', '5')
+expect(exit_code).to eq(0)
+expect(stdout.strip).to eq('15.00')
+```
+
+## Features
+
+- 🔨 **Automatic compilation** - Builds your Go CLI app before tests
+- 📦 **Binary name detection** - Extracts binary name from `go.mod`
+- 📁 **Smart directory detection** - Automatically finds `cmd/` directory if present
+- 🔒 **Environment isolation** - Each test runs in isolated temp directory with custom `$HOME`
+- 🎯 **Simple API** - Easy setup/teardown and execution methods
+- ⚡ **Timeout control** - Configurable timeout for command execution
+- 🐛 **Debug mode** - Detailed logging for troubleshooting
+- 🔧 **Custom build flags** - Support for any Go build options
+- ✅ **Error handling** - Clear error messages for common issues
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'go-cli-test-support'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install go-cli-test-support
+```
+
+## Usage
+
+### Basic Example
+
+```ruby
+require 'rspec'
+require 'go-cli-test-support'
+
+RSpec.describe 'My CLI App' do
+  include GoTestHelper
+
+  before(:each) do
+    setup_go_test('/path/to/your/go/project')
+  end
+
+  after(:each) do
+    teardown_go_test
+  end
+
+  it 'runs successfully' do
+    exec('--version')
+    expect(exit_code).to eq(0)
+    expect(stdout).to include('1.0.0')
+  end
+end
+```
+
+### Directory Structure Support
+
+The helper supports multiple Go project structures:
+
+#### Standard Structure
+```
+my-project/
+├── go.mod
+└── main.go
+```
+
+#### cmd/ Directory Structure
+```
+my-project/
+├── go.mod
+└── cmd/
+    └── main.go
+```
+
+The helper automatically detects and uses the `cmd/` directory if present.
+
+### API Reference
+
+#### `setup_go_test(project_dir, compile_path: nil, build_flags: [])`
+
+Prepares the test environment:
+- Creates isolated temporary directory
+- Compiles the Go binary
+- Detects binary name from `go.mod`
+
+**Parameters:**
+- `project_dir` (String): Path to your Go project root (where `go.mod` is located)
+- `compile_path` (String, optional): Override the directory to compile from
+- `build_flags` (Array, optional): Custom Go build flags (e.g., `-ldflags`, `-tags`)
+
+**Raises:**
+- `ArgumentError`: If project directory doesn't exist or `go.mod` is missing
+
+**Example:**
+```ruby
+# Auto-detect compile directory
+setup_go_test('/path/to/project')
+
+# Explicit compile path
+setup_go_test('/path/to/project', compile_path: '/path/to/project/cmd')
+
+# With custom build flags
+setup_go_test('/path/to/project', build_flags: ['-ldflags', '-s -w'])
+
+# Multiple options
+setup_go_test(
+  '/path/to/project',
+  compile_path: '/path/to/project/cmd',
+  build_flags: ['-v', '-tags', 'integration']
+)
+```
+
+#### `teardown_go_test`
+
+Cleans up the temporary test directory. Call this in `after(:each)` or `after(:all)`.
+
+#### `exec(*args, stdin: nil, timeout: 30)`
+
+Executes the compiled binary with given arguments.
+
+**Parameters:**
+- `*args`: Command-line arguments to pass to the binary
+- `stdin` (String, optional): Data to send to stdin
+- `timeout` (Integer, optional): Command timeout in seconds (default: 30)
+
+**Returns:** `self` (for method chaining)
+
+**Timeout Behavior:**
+- If command exceeds timeout, `exit_code` will be 124
+- `stderr` will contain timeout message
+- `stdout` will be empty
+
+**Example:**
+```ruby
+exec('add', 'task')
+exec('list')
+exec('input', stdin: "some data\n")
+
+# Custom timeout
+exec('long-command', timeout: 60)
+
+# Check for timeout
+exec('command', timeout: 5)
+if exit_code == 124
+  puts "Command timed out!"
+end
+```
+
+#### Accessors
+
+After calling `exec`, you can access:
+
+- `stdout` - Standard output from the command
+- `stderr` - Standard error from the command
+- `exit_code` - Exit code of the command
+- `test_dir` - Path to the isolated test directory
+
+#### Debug Mode
+
+Enable debug mode to see detailed execution information:
+
+```ruby
+self.debug = true  # Enable debug output
+self.debug = false # Disable debug output
+```
+
+When enabled, you'll see:
+- Build command details
+- Execution details
+- Exit codes
+- stdout/stderr content
+
+### Complete Example
+
+```ruby
+require 'rspec'
+require 'go-cli-test-support'
+
+RSpec.describe 'Todo CLI' do
+  include GoTestHelper
+
+  let(:project_dir) { File.expand_path('../my-todo-app', __dir__) }
+
+  before(:each) do
+    setup_go_test(project_dir)
+  end
+
+  after(:each) do
+    teardown_go_test
+  end
+
+  it 'shows usage when no arguments' do
+    exec
+    expect(exit_code).to eq(1)
+    expect(stdout).to include('Usage:')
+  end
+
+  it 'can add and list todos' do
+    exec('add', 'Buy milk')
+    expect(exit_code).to eq(0)
+    expect(stdout).to include('Added')
+
+    exec('list')
+    expect(stdout).to include('Buy milk')
+  end
+
+  it 'isolates data between tests' do
+    # Each test gets a fresh $HOME directory
+    exec('add', 'Task 1')
+    
+    data_file = File.join(test_dir, 'todos.json')
+    expect(File.exist?(data_file)).to be true
+  end
+end
+```
+
+### Advanced Usage
+
+#### Debug Mode
+```ruby
+RSpec.describe 'My App' do
+  include GoTestHelper
+
+  before(:each) do
+    self.debug = true  # Enable detailed logging
+    setup_go_test(project_dir)
+  end
+
+  it 'debugs execution' do
+    exec('command')
+    # [GoTestHelper DEBUG] Executing: /tmp/app_test_xxx/app command
+    # [GoTestHelper DEBUG] Exit code: 0
+  end
+end
+```
+
+#### Custom Build Flags
+```ruby
+before(:each) do
+  # Production build with optimizations
+  setup_go_test(
+    project_dir,
+    build_flags: ['-ldflags', '-s -w', '-tags', 'production']
+  )
+end
+```
+
+#### Timeout Handling
+```ruby
+it 'handles long-running commands' do
+  exec('backup', timeout: 300)  # 5 minutes
+  
+  if exit_code == 124
+    puts "Backup timed out"
+  end
+end
+```
+
+#### Error Handling
+```ruby
+it 'handles setup errors gracefully' do
+  expect {
+    setup_go_test('/invalid/path')
+  }.to raise_error(ArgumentError, /does not exist/)
+end
+```
+
+## How It Works
+
+1. **Compilation**: Compiles your Go app to a temporary directory
+2. **Binary Naming**: Extracts the binary name from your `go.mod` module path (e.g., `github.com/user/my-app` → `my-app`)
+3. **Isolation**: Sets `$HOME` to the test directory, isolating config files and data
+4. **Execution**: Runs the binary with provided arguments and captures output
+
+## Requirements
+
+- Ruby >= 2.7.0
+- Go installed and available in PATH
+- RSpec ~> 3.12
+
+## Development
+
+After checking out the repo, run:
+
+```bash
+bundle install
+rspec
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/go-cli-test-support.rb

@@ -0,0 +1,89 @@
+require 'open3'
+require 'fileutils'
+require 'tmpdir'
+require 'timeout'
+
+module GoTestHelper
+  attr_reader :test_dir, :stdout, :stderr, :exit_code
+  attr_accessor :debug
+  
+  def setup_go_test(project_dir, compile_path: nil, build_flags: [])
+    raise ArgumentError, "Project directory does not exist: #{project_dir}" unless Dir.exist?(project_dir)
+    
+    go_mod = File.join(project_dir, 'go.mod')
+    raise ArgumentError, "go.mod not found in #{project_dir}" unless File.exist?(go_mod)
+    
+    binary_name = detect_binary_name(project_dir)
+    @test_dir = Dir.mktmpdir("#{binary_name}_test_")
+    
+    build_dir = compile_path || detect_build_dir(project_dir)
+    @binary = File.join(@test_dir, binary_name)
+    
+    build_cmd = ['go', 'build', *build_flags, '-o', @binary]
+    
+    debug_log "Building Go binary: #{build_cmd.join(' ')}"
+    debug_log "Build directory: #{build_dir}"
+    
+    _, stderr, status = Open3.capture3(*build_cmd, chdir: build_dir)
+    raise "Compile failed:\n#{stderr}" unless status.success?
+    
+    debug_log "Binary created: #{@binary}"
+  end
+  
+  def teardown_go_test
+    FileUtils.rm_rf(@test_dir) if @test_dir && Dir.exist?(@test_dir)
+  end
+  
+  def exec(*args, stdin: nil, timeout: 30)
+    debug_log "Executing: #{@binary} #{args.join(' ')}"
+    debug_log "Working directory: #{@test_dir}"
+    debug_log "Timeout: #{timeout}s"
+    
+    begin
+      Timeout.timeout(timeout) do
+        @stdout, @stderr, status = Open3.capture3(
+          { 'HOME' => @test_dir },
+          @binary, *args,
+          stdin_data: stdin,
+          chdir: @test_dir
+        )
+        @exit_code = status.exitstatus
+      end
+    rescue Timeout::Error
+      @stdout = ''
+      @stderr = "Command timed out after #{timeout} seconds"
+      @exit_code = 124
+      debug_log "Command timed out!"
+    end
+    
+    debug_log "Exit code: #{@exit_code}"
+    debug_log "STDOUT: #{@stdout}" if @debug && !@stdout.empty?
+    debug_log "STDERR: #{@stderr}" if @debug && !@stderr.empty?
+    
+    self
+  end
+  
+  private
+  
+  def debug_log(message)
+    puts "[GoTestHelper DEBUG] #{message}" if @debug
+  end
+  
+  def detect_binary_name(project_dir)
+    go_mod = File.join(project_dir, 'go.mod')
+    return 'app' unless File.exist?(go_mod)
+    
+    content = File.read(go_mod)
+    if content =~ /^module\s+(.+)$/
+      $1.split('/').last.strip
+    else
+      'app'
+    end
+  end
+  
+  def detect_build_dir(project_dir)
+    cmd_dir = File.join(project_dir, 'cmd')
+    return cmd_dir if Dir.exist?(cmd_dir)
+    project_dir
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: go-cli-test-support
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Hiroaki Satou
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+description: A Ruby gem that compiles Go CLI applications to binaries and enables
+  testing with RSpec using a DSL-like syntax for command-line arguments. It automatically
+  handles compilation, execution, and environment isolation, making it easy to capture
+  stdout/stderr/exit_code in your tests.
+email:
+- your.email@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/go-cli-test-support.rb
+homepage: https://github.com/hiroakisatou/go-cli-test-support
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/hiroakisatou/go-cli-test-support
+  source_code_uri: https://github.com/hiroakisatou/go-cli-test-support
+  changelog_uri: https://github.com/hiroakisatou/go-cli-test-support/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: RSpec test helper for Go CLI applications
+test_files: []