customized template for iOS test reports
A plugin for the Cinch IRC framework to search YouTube and deliver the top three results from the specified search. You can visit irc://rawr.sinsira.net #Lobby to get help, report issues , test the gem, or just chat.
report your test coverage to idobata.io.
# ruby unshare (runshare) This tool allows to unshare Linux namespaces. The implementation is similar to the unshare(1) tool. ## Installation Add this line to your application's Gemfile: ```ruby gem 'runshare' ``` And then execute: $ bundle Or install it yourself as: $ gem install runshare ## Usage > require "runshare" > RUnshare::unshare For example: cat > test.rb require "runshare" pid = RUnshare::unshare( :clone_newpid => true, :clone_newns => true, :clone_newcgroup => true, :clone_newipc => true, :clone_newuts => true, :clone_newnet => true, :clone_newtime => true, :fork => true, :mount_proc => "/proc", # docker export $(docker create hello-world) | tar -xf - -C rootfs :root => "/tmp/rootfs" ) if pid == 0 # child puts "--- #{Process.pid}" if system("/hello") != true raise "bad" end puts "--- done" else # parent puts "-- unshare=#{pid}, pid=#{Process.pid}" puts "-- exit=#{Process.waitpid(pid)}" end ^D sudo ruby -I ./lib ./test.rb ## Quick start $ rake compile && echo 'require "runshare"; RUnshare::unshare(:clone_newuts => true)' | irb install -c tmp/x86_64-linux/runshare/2.4.10/runshare.so lib/runshare/runshare.so cp tmp/x86_64-linux/runshare/2.4.10/runshare.so tmp/x86_64-linux/stage/lib/runshare/runshare.so Switch to inspect mode. require "runshare"; RUnshare::unshare ## Ruby <2.5 If your app is single threaded and you are observing: eval:1: warning: pthread_create failed for timer: Invalid argument, scheduling broken Just ignore it with some degree of bravity. You also can silence it by setting: $VERBOSE = nil ## Development After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org). ## Contributing Bug reports and pull requests are welcome on GitHub at https://github.com/sitano/runshare. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct. ## License The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
Simple Minitest reporter to indicate the result of test runs. After every test run, the reporter invokes the `minitest-flash` executable (created by you and to your liking) with either the argument "green" or "red" to reflect the result of the run.
Report CircleCI test coverage and static analysis results to your GitHub repository
A Minitest reporter optimized for Large Language Model consumption, featuring compact emoji-based output, regression detection by comparing test runs, TOML report generation, and detailed failure reporting with file locations. Perfect for AI-assisted development workflows.
# SshSig - SSH signature verification in pure ruby SshSig is a Ruby gem which can be used to verify signatures signed created by `ssh-keygen`. This capability was [first added](https://github.com/openssh/openssh-portable/commit/2a9c9f7272c1e8665155118fe6536bebdafb6166) in OpenSSH 8.0 allows SSH keys to be used for GPG-like signing capabilities, [including signing git commits](https://github.com/git/git/pull/1041). ## Installation Add this line to your application's Gemfile: ```ruby gem 'ssh_sig' ``` And then execute: $ bundle install Or install it yourself as: $ gem install ssh_sig ## Usage Version 1 of [the SSH signature format](https://github.com/openssh/openssh-portable/blob/b7ffbb17e37f59249c31f1ff59d6c5d80888f689/PROTOCOL.sshsig) supports `ed25519` and `rsa` keys. It is recommended that you use `ed25519` over `rsa` where possible (`ssh-keygen -t ed25519`). In order to verify a signature you need: 1. The public key of the sender 1. The signature file 1. The message to be verified. ```ruby require 'ssh_sig' armored_pubkey = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAILXPkJPI4TMFWZP4xRBQjNeizUG99KuZCt9G23rX48kz" blob = ::SshSig::Blob.from_armor( <<~EOF -----BEGIN SSH SIGNATURE----- U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgtc+Qk8jhMwVZk/jFEFCM16LNQb 30q5kK30bbetfjyTMAAAAEZmlsZQAAAAAAAAAGc2hhNTEyAAAAUwAAAAtzc2gtZWQyNTUx OQAAAECJITeYJIlEeydsCTh1DkfdhlDJFBa73ojfWe0MbrIzoJKd9THd9WeQrhygSRGsNG cU/stk3/919nykg67yG2gN -----END SSH SIGNATURE----- EOF ) message = "This message was definitely sent by Brian Williams" valid = ::SshSig::Verifier .from_armored_pubkey(armored_pubkey) .verify(blob, message) if valid puts 'Signature is valid' else puts 'Signature is not valid' end ``` Signatures can be created using `ssh-keygen -Y sign -n file -f ~/.ssh/ed_25519 message.txt` and will be outputted in `message.txt.sig`. Public keys can be found in a variety of places, including: - Your `~/.ssh/id_<alg>.pub` file - `authorized_keys` files on servers - `https://gitlab.com/<username>.keys` - `https://github.com/<username>.keys` The `SshSig::Verifier#from_gitlab` and `SshSig::Verifier#from_github` methods are provided to automatically load public keys from the respective `<username>.keys` urls. ```ruby require 'ssh_sig' blob = ::SshSig::Blob.from_armor( <<~EOF -----BEGIN SSH SIGNATURE----- U1NIU0lHAAAAAQAAADMAAAALc3NoLWVkMjU1MTkAAAAgtc+Qk8jhMwVZk/jFEFCM16LNQb 30q5kK30bbetfjyTMAAAAEZmlsZQAAAAAAAAAGc2hhNTEyAAAAUwAAAAtzc2gtZWQyNTUx OQAAAECJITeYJIlEeydsCTh1DkfdhlDJFBa73ojfWe0MbrIzoJKd9THd9WeQrhygSRGsNG cU/stk3/919nykg67yG2gN -----END SSH SIGNATURE----- EOF ) message = 'This message was definitely sent by Brian Williams' valid = ::SshSig::Verifier .from_gitlab('bwill') .verify(blob, message) if valid puts 'Signature is valid' else puts 'Signature is not valid' end ``` ## Is it safe to re-purpose SSH keys for signing? Yes. The [SSH signature protocol](https://github.com/openssh/openssh-portable/blob/d575cf44895104e0fcb0629920fb645207218129/PROTOCOL.sshsig) is designed to be resistant to cross-protocol attacks, where signatures created for one purpose (i.e. signing a git commit), may be re-used for another purpose (i.e. authenticating to a server). It does this using the magic pre-amble (to differentiate between messages signed by `ssh-keygen` and messages used for SSH authentication) and namespaces (to differentiate between messages signed by `ssh-keygen` but used for different purposes). This causes identical messages to produce different signatures for each different protocol. ## Development After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org). ## Contributing Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/ssh_sig. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/ssh_sig/blob/main/CODE_OF_CONDUCT.md). ## License The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
A TAP test report defines several properties for each tests. The objective of the gem is to provide all the specified properties after parsing the report either from the file or text.
SpecTimer is a testing hook that reports specs which took too long to run
Create lucid test reports from Cucumber JSON results.
Towel collects test results as they run, reporting them to towel.dev for easier inspection, debugging, and sharing.
Minitest override which treats tests without assertions as having been skipped for reporting purposes.
# Optio Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/optio`. To experiment with that code, run `bin/console` for an interactive prompt. ## Installation Add this line to your application's Gemfile: ```ruby gem 'optio' ``` And then execute: $ bundle Or install it yourself as: $ gem install optio ## Usage Write usage instructions here ## Development After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org). ## Contributing Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/optio. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct. ## License The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT). ## Code of Conduct Everyone interacting in the Optio project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/optio/blob/master/CODE_OF_CONDUCT.md).
Generate a human readable report for CodeClimate test-reporter gem.
Parse test results from various sources and post reports to Slack
I am testing for brandjacking vulnerabilities in products that are in bug bounty programs. This code is reporting-only, and does not do anything malicious.
Evaluates NanoFlags feature flags locally (the same engine and results as every NanoFlags SDK), keeps the configuration current in background threads (live WebSocket pushes, with the event stream and ETag polling as fallback), verifies bundle signatures, resolves test sessions (Rack middleware), survives forks (Puma, Unicorn, Passenger, Resque) and reports sampled, redacted evaluation telemetry. No runtime dependencies.
Karst tests Rails routes as a bounded set of existing users and reports runtime access evidence.
This is an HTML test report format for the Rubytest metaframework.
CapyDash automatically generates clean, readable HTML test reports after your RSpec or Minitest suite finishes. Zero configuration required.
uncov compares your current branch with a target branch, identifies changed files, and reports on test coverage for those changes
CI::Reporter is an add-on to Test::Unit, RSpec and Cucumber that allows you to generate XML reports of your test, spec and/or feature runs. The resulting files can be read by a continuous integration system that understands Ant's JUnit report XML format, thus allowing your CI system to track test/spec successes and failures.
# Mint::Money Mint::Money perform currency conversion and arithmetics with different currencies. ## Installation Add this line to your application's Gemfile: ```ruby gem 'mint-money' ``` And then execute: $ bundle Or install it yourself as: $ gem install mint-money ## Usage ``` # Configure the currency rates with respect to a base currency (here EUR): Money.conversion_rates('EUR', { 'USD' => 1.11, 'Bitcoin' => 0.0047 }) ``` ``` # Instantiate money objects: fifty_eur = Money.new(50, 'EUR') # Get amount and currency: fifty_eur.amount # => 50 fifty_eur.currency # => "EUR" fifty_eur.inspect # => "50.00 EUR" ``` ``` # Convert to a different currency (should return a Money # instance, not a String): fifty_eur.convert_to('USD') # => 55.50 USD ``` ``` # Perform operations in different currencies: twenty_dollars = Money.new(20, 'USD') # Arithmetics: fifty_eur + twenty_dollars # => 68.02 EUR fifty_eur - twenty_dollars # => 31.98 EUR fifty_eur / 2 # => 25 EUR twenty_dollars * 3 # => 60 USD ``` ``` # Comparisons (also in different currencies): twenty_dollars == Money.new(20, 'USD') # => true twenty_dollars == Money.new(30, 'USD') # => false fifty_eur_in_usd = fifty_eur.convert_to('USD') fifty_eur_in_usd == fifty_eur # => true twenty_dollars > Money.new(5, 'USD') # => true twenty_dollars < fifty_eur # => true ``` ## Development After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org). ## Contributing Bug reports and pull requests are welcome on GitHub at https://github.com/mpakus/mint-money. [](https://circleci.com/gh/mpakus/mint-money)
An amazingly simple way to test & debug with assertions -- right in your code! Allows you to test inline without writing any seperate unit tests as everything is mixed into pour code. This helps ensure, for web apps like Rails, that if something has gone wrong that shouldn't it gets reported in your logs without having to worry about exception raising and rescuing. Want a unit testing library? This small library can get you started in the right direction!
This gem is empty. It protects against brandjacking. You are welcome. If you think it is yours to own, just contact me.
Runs multiple test suites, collecting and reporting back an aggregate result. Useful for large, multilingual projects.
rcov is a code coverage tool for Ruby. It is commonly used for viewing overall test unit coverage of target code. It features fast execution (20-300 times faster than previous tools), multiple analysis modes, XHTML and several kinds of text reports, easy automation with Rake via a RcovTask, fairly accurate coverage information through code linkage inference using simple heuristics, colorblind-friendliness...
NOTE: This is a fork of ci-reporter/ci_reporter_test_unit
Runs around your test suite in CI and measures your Rails app's tests, deprecations and runtimes for a gemfile.io upgrade report.
Regex Tester tests regular expressions against input strings across operations like match, search, replace, and split. It reports compilation validity, syntax error details, execution timing, and structural pattern analysis.
Zizek is a native property-based testing for Ruby, modeled on Hegel and Hypothesis. It explores generated examples, records every choice, shrinks the first failure to a minimal counterexample, and reports a reproduce blob that replays that exact example.
Minitest integration for Mergify Test Engine: the run reported to CI Insights, test quarantine, Fail First on merge-queue bisection steps, and flaky test detection.
TLS Checker tests which TLS protocol versions a server accepts by running a live handshake for each of TLS 1.0, 1.1, 1.2 and 1.3. It reports the highest version, the cipher the server picks, whether the certificate validates, whether deprecated protocols are still exposed, a risk score and a letter grade from a published rubric.
Scully statically checks RSpec and Minitest suites with Prism, without running them, and reports tests that check nothing or can never fail.
mutaruby changes your code in small ways (mutants) and runs your test command against each change. A mutant your tests do not notice is a gap in your tests. Works with any test command (rspec, minitest, rake), runs every mutant in a fresh process inside a private copy of the project, and reports a mutation score as text, JSON or JUnit XML.
saboteur makes small deliberate changes to your methods, runs only the tests that cover each change, and reports the changes no test notices.
Point rails-preflight at a Rails app and a target version. It reads the lockfile, .ruby-version, Dockerfile, db/schema.rb and config, and scans Ruby, ERB, HAML and Slim files for removed APIs, then writes a single HTML report: blockers, items to fix, what it couldn't check, and a suggested path with one step per Rails minor version. The same findings print as Markdown for coding agents or JSON for CI. Read-only and static. It never modifies the app, runs it, or runs its tests.
scrap4rb reads Minitest test files and scores each test for size, branching, mocking, weak assertions and duplicated scaffolding. Per file it reports a refactor pressure, a remediation mode and an actionability class for an AI assistant. A Ruby port of the SCRAP algorithm by Robert C. Martin.
Mutates methods with Prism, redefines them in forked children of a test process booted once, selects the tests that cover each mutant from per-test coverage, and reports the survivors. RSpec or Minitest.
rcov is a code coverage tool for Ruby. It is commonly used for viewing overall test unit coverage of target code. It features fast execution (20-300 times faster than previous tools), multiple analysis modes, XHTML and several kinds of text reports, easy automation with Rake via a RcovTask, fairly accurate coverage information through code linkage inference using simple heuristics, colorblind-friendliness...
Parse test, coverage, and benchmark reports into deterministic PNG and Markdown summaries.
Constable replaces RSpec/Minitest for Rails apps that want tests to be fast and non-flaky by construction. Every test is isolated by default, nondeterminism is a lint error rather than a CI surprise, and every escape hatch is reported until someone deals with it. Existing RSpec and Minitest suites adopt it with a one-line change per file and zero rewriting -- cold cases run verbatim through their original engine while native cases run under strict rules, side by side in one run. Ships with a case-file DSL (investigate/witness/briefing/docket), transactional isolation, flake history with rename-surviving content-hash identity, a jail and parole docket for legacy red suites, warrants for automatic flake detection, diff-based coverage, parallel workers, git-diff test selection, and a RuboCop extension. The gem is published as "constable-rails"; everything inside it -- the module, the CLI, the config directory -- is simply "constable".
SpecGuard's Ruby client — every Ruby test framework, one gem. Ships an additive RSpec formatter and a Minitest reporter that post test-run telemetry to SpecGuard's ingest endpoint, a CLI linter (specguard-lint) that validates OpenTestIntent @intent annotations in *_spec.rb files, and a replayer (specguard-ingest) that re-delivers a run saved when the endpoint could not be reached. Telemetry never blocks CI; the linter blocks only on malformed annotations.
txray parses your Rails application with Prism and follows callbacks, concerns and helper methods to find HTTP requests, external service clients, mail delivery, job enqueues, subprocesses and unbounded loops running inside database transactions. It needs no application boot and no test coverage, so it reports problems on code paths your suite never executes. An optional runtime guard reports the same problems from a running application.
Test coverage reports for Xcode projects
JSON Schema Validator is a JSON validator API that tests any JSON object against a JSON Schema you provide, so you can check JSON against its schema before trusting it. It reports pass-fail status and total error count, while paid plans add specific error messages.
Generate HTML test reports more easily.
A simple mutation testing framework that runs tests in parallel, generates detailed reports, and helps improve test quality by identifying weak spots in your test suite. Especially useful for you AI workflow
Combines Ruby's native Coverage execution counts with Prism AST analysis to map per-test coverage onto semantic units (methods, branches, conditions), find redundant tests grouped by duplication type with confidence levels, and emit a removal patch — never deleting a test that would open a coverage gap. Report + patch only; asks for approval before any change.