Test Coverage

Code coverage for Ruby with a powerful configuration library and automatic merging of coverage across test suites

ChefSpec is a unit testing and resource coverage (code coverage) framework for testing Chef cookbooks ChefSpec makes it easy to write examples and get fast feedback on cookbook changes without the need for virtual machines or cloud servers.

Test coverage reports for Xcode projects

Collects test coverage data from your Ruby test suite and sends it to Code Climate's hosted, automated code review service. Based on SimpleCov.

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...

"Code coverage tool for ruby 2.0 to 2.3. Simply "require 'coco'" from rspec or unit/test. Build simple html report. Report sources that have no tests. Configurable if you need to.

Parses xcresult files for viewing test summaries and code coverages

= Mcrypt - libmcrypt bindings for Ruby Mcrypt provides Ruby-language bindings for libmcrypt(3), a symmetric cryptography library. {Libmcrypt}[http://mcrypt.sourceforge.net/] supports lots of different ciphers and encryption modes. == You will need * A working Ruby installation (>= 1.8.6 or 1.9) * A working libmcrypt installation (2.5.x or 2.6.x, tested with 2.5.8) * A sane build environment == Installation Install the gem: gem install ruby-mcrypt --test -- --with-mcrypt-dir=/path/to/mcrypt/prefix If you're installing on Ubuntu: sudo apt-get install mcrypt libmcrypt-dev gem install ruby-mcrypt If you want to run the longer test suite, do this instead: MCRYPT_TEST_BRUTE=1 \ gem install ruby-mcrypt --test -- --with-mcrypt-dir=/path/to/mcrypt/prefix Put this in your code: require 'rubygems' require 'mcrypt' Or in Rails' environment.rb: gem "ruby-mcrypt", :lib => "mcrypt" == Usage crypto = Mcrypt.new(:twofish, :cbc, MY_KEY, MY_IV, :pkcs) # encryption and decryption in one step ciphertext = crypto.encrypt(plaintext) plaintext = crypto.decrypt(ciphertext) # encrypt in smaller steps while chunk = $stdin.read(4096) $stdout << crypto.encrypt_more(chunk) end $stdout << crypto.encrypt_finish # or decrypt: while chunk = $stdin.read(4096) $stdout << crypto.decrypt_more(chunk) end $stdout << crypto.decrypt_finish == Known Issues * Test coverage is lacking. If you find any bugs, please let the author know. == Wish List * IO-like behavior, e.g. crypto.open($stdin) { |stream| ... } == Author * Philip Garrett <philgarr at gmail.com> == Copyright and License Copyright (c) 2009-2013 Philip Garrett. 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.

Report your Ruby app test suite code coverage with Danger.

Creates an after suite hook in RSpec that dynamically creates and injects a new test case that expects the actual code coverage to be at least the lower limit set in SimpleCov.

RSpec Tracer is a specs dependency analyzer, flaky tests detector, tests accelerator, and coverage reporter tool for RSpec. It maintains a list of files for each test, enabling itself to skip tests in the subsequent runs if none of the dependent files are changed. It uses Ruby's built-in coverage library to keep track of the coverage for each test.

Provides a coverage of I18n keys used during test suite

A set of tools to support reporting SimpleCov Coverage to CodeClimate with Parallel tests on CircleCI

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...

One Rake task to give you rcov code coverage for your rails app. rake test:coverage

Generates coverage report for routes hit by your request/integration/feature tests including capybara ones

A gem that runs jasmine javascript tests with all the goodness of coverage reports.

A simple code coverage tool for Ruby 1.9. Add 'Duvet.start' to the top of your test helper, to have it write code coverage stuff to 'cov/'.

Lazy coverage-aware running of Cucumber acceptance tests

Report test coverage to your GitHub repository

print coverage per test file

RubyBHL is a simple but flexible request/response wrapper for the Biodiversity Heritage Libary API. It includes (some) validation for request formatting. It has excellent unit-test coverage.

Lazy coverage-aware running of Cucumber acceptance tests

Tools for collecting code coverage from tests.

Solargraph Plugin that reports line/branch coverage from unit tests

A configurable Coveralls client that supports merging coverage from multiple languages & test suites.

Rails gem for Mashery. Clean config and includes tests with decent test coverage

Helper to setup good coverage for tests

# XQuery [](https://gitter.im/JelF/xquery?utm_source=badge&amp;utm_medium=badge&amp;utm_campaign=pr-badge&amp;utm_content=badge) [](https://travis-ci.org/JelF/xquery) [](https://codeclimate.com/github/JelF/xquery) [](https://codeclimate.com/github/JelF/xquery/coverage) [](https://codeclimate.com/github/JelF/xquery) XQuery is designed to replace boring method call chains and allow to easier convert it in a builder classes ## Usage of `XQuery` function `XQuery` is a shortcat to `XQuery::Generic.with` ``` r = XQuery(''.html_safe) do |q| # similar to tap q &lt;&lt; 'bla bla bla' q &lt;&lt; 'bla bla bla' # using truncate q.truncate(15) # real content (q.send(:query)) mutated q &lt;&lt; '!' end r # =&gt; "bla bla blab...!" ``` ## Usage of `XQuery::Abstract` I designed this gem to help me with `ActiveRecord` Queries, so i inherited `XQuery::Abstract` and used it's powers. It provides the following features ### `wrap_method` and `wrap_methods` when you call each of this methods they became automatically wrapped (`XQuery::Abstract` basically wraps all methods query `#respond_to?`) It means, that there are instance methods with same name defined and will change a `#query` to their call result. ``` self.query = query.foo(x) # is basically the same as foo(x) # when `wrap_method :foo` called ``` You can also specify new name using `wrap_method :foo, as: :bar` syntax ### `q` object `q` is a proxy object which holds all of wrapped methods, but not methods you defined inside your class. E.g. i have defined `wrap_method(:foo)`, but also delegated `#foo` to some another object. If i call `q.foo`, i will get wrapped method. Note, that if you redefine `#__foo` method, q.foo will call it instead of normal work. You can add additional methods to `q` using something like `alias_on_q :foo`. I used it with `kaminary` and it was useful ``` def page=(x) apply { |query| query.page(x) } end alias_on_q :page= def page query.current_page end alias_on_q :page ``` ### `query_superclass` You should specify `query_superclass` class_attribute to inherit `XQuery::Abstract`. Whenever `query.is_a?(query_superclass)` evaluate to false, you will get `XQuery::QuerySuperclassChanged` exception. It can save you much time when your class misconfigured. E.g. you are using `select!` and it returns `nil`, because why not? ### `#apply` method `#apply` does exact what it source tells ``` # yields query inside block # @param block [#to_proc] # @return [XQuery::Abstract] self def apply(&amp;block) self.query = block.call(query) self end ``` It is usefull to merge different queries. ### `with` class method You can get XQuery functionality even you have not defined a specific class (You are still have to inherit XQuery::Abstract to use it) You can see it in this document when i described `XQuery` function. Note, that it yields a class instance, not `q` object. It accepts any arguments, they will be passed to a constructor (except block) ### `execute` method Preferred way to call public instance methods. Resulting query would be returned

Blindfold brings together RSpec, Rack::Test, and Machinist for the express purpose of providing integration test coverage for web based API services (especially those with an XML response).

Ruby's contemporary test coverage tools all lie, exaggerating coverage through false-positives and creating a false sense of security; minitest-coverage tries to address this. Coverage Analysis Tools rely on tracing facilities built into ruby’s VM. You run your tests, and collect data. Seems simple, but that’s a very flawed approach that buffers your coverage numbers up falsely. I’ve witnessed false coverage by as much as 60%, but it could be even worse. Worse, the tracing facilities currently make it impossible to get truly accurate numbers. Even so, they can be improved to be much more accurate.

Lookout-Rake Lookout-Rake provides Rake¹ tasks for testing using Lookout. ¹ See http://rake.rubyforge.org/ § Installation Install Lookout-Rake with % gem install lookout-rake § Usage Include the following code in your ‹Rakefile›: require 'lookout-rake-3.0' Lookout::Rake::Tasks::Test.new If the ‹:default› task hasn’t been defined it’ll be set to depend on the ‹:test› task. The ‹:check› task will also depend on the ‹:test› task. There’s also a ‹:test:coverage› task that gets defined that uses the coverage library that comes with Ruby 1.9 to check the test coverage when the tests are run. You can hook up your test task to use your Inventory¹: load File.expand_path('../lib/library-X.0/version.rb', __FILE__) Lookout::Rake::Tasks::Test.new :inventory => Library::Version Also, if you use the tasks that come with Inventory-Rake², the test task will hook into the inventory you tell them to use automatically, that is, the following will do: load File.expand_path('../lib/library-X.0/version.rb', __FILE__) Inventory::Rake::Tasks.define Library::Version Lookout::Rake::Tasks::Test.new For further usage information, see the {API documentation}³. ¹ Inventory: http://disu.se/software/inventory/ ² Inventory-Rake: http://disu.se/software/inventory-rake/ ³ API: http://disu.se/software/lookout-rake/api/Lookout/Rake/Tasks/Test/ § Integration To use Lookout together with Vim¹, place ‹contrib/rakelookout.vim› in ‹~/.vim/compiler› and add compiler rakelookout to ‹~/.vim/after/ftplugin/ruby.vim›. Executing ‹:make› from inside Vim will now run your tests and an errors and failures can be visited with ‹:cnext›. Execute ‹:help quickfix› for additional information. Another useful addition to your ‹~/.vim/after/ftplugin/ruby.vim› file may be nnoremap <buffer> <silent> <Leader>M <Esc>:call <SID>run_test()<CR> let b:undo_ftplugin .= ' | nunmap <buffer> <Leader>M' function! s:run_test() let test = expand('%') let line = 'LINE=' . line('.') if test =~ '^lib/' let test = substitute(test, '^lib/', 'test/', '') let line = "" endif execute 'make' 'TEST=' . shellescape(test) line endfunction Now, pressing ‹<Leader>M› will either run all tests for a given class, if the implementation file is active, or run the test at or just before the cursor, if the test file is active. This is useful if you’re currently receiving a lot of errors and/or failures and want to focus on those associated with a specific class or on a specific test. ¹ Find out more about Vim at http://www.vim.org/ § Financing Currently, most of my time is spent at my day job and in my rather busy private life. Please motivate me to spend time on this piece of software by donating some of your money to this project. Yeah, I realize that requesting money to develop software is a bit, well, capitalistic of me. But please realize that I live in a capitalistic society and I need money to have other people give me the things that I need to continue living under the rules of said society. So, if you feel that this piece of software has helped you out enough to warrant a reward, please PayPal a donation to now@disu.se¹. Thanks! Your support won’t go unnoticed! ¹ Send a donation: https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=now%40disu%2ese&item_name=Nikolai%20Weibull%20Software%20Services § Reporting Bugs Please report any bugs that you encounter to the {issue tracker}¹. ¹ See https://github.com/now/lookout-rake/issues § Authors Nikolai Weibull wrote the code, the tests, the manual pages, and this README.

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...

A small gem that posts simplecovs test coverage to a web service. We've built a web service for rendering coverage badge svgs too. You can find it at coverage.traels.it

Rails gem for Mashery. Clean config and includes tests with decent test coverage

Handy thing to ensure 100% test coverage for Ruby 1.9 projects

== DESCRIPTION: Provides a script and library to parse stories saved in the RSpec plain text story format and creates a PDF file with printable 3&quot;x5&quot; index cards suitable for using in Agile planning and prioritization. == FEATURES/PROBLEMS: * Create a PDF with each page as a 3x5 sheet, or as 4 cards per 8.5 x 11 sheet * Included script reads stories from STDIN and writes PDF to STDOUT * TODO: Improve test coverage * TODO: Improve documentation == SYNOPSIS: From the command line with stories2cards &lt; /path/to/stories.txt Or via Ruby story_text = File.read('my_story') pdf_content = PDF::Storycards::Writer.make_pdf(story_text, :style =&gt; :card_1up) == REQUIREMENTS:

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...

Uncool is a unit testing coverage tool that monitors tests recording all the methods covered for the tarageted namespaces.

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...

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...

Filter test results to include only the system under test. A port of minitest-coverage

Ansible Config Parser for Serverspec to test roles, hosts and playbooks. Providing test coverage.

This library provides the ability to measure the code coverage for Ruby 1.9.

Generates a CSS coverage report and tests for minimum coverage

QAT Reporter is a collection of tool for generating test report information such as: - Requirement Coverage - Time Measurements

Rails engine that gets SimpleCov up and running for you in a parallelized test suite

autocoverage runs rcov code coverage on your code whenever your library or test code changes. autoflog runs flog code analysis on your library code. autotoken runs saikuro's token complexity on your library code. autocyclo runs saikuro's cyclomatic complexity on your library code.

🎙 Easily generate RSS podcast feeds from a simple JSON object (100% test coverage, compatible with every major podcast player)

Uploads test coverage data to Bitbucket Server via Code Coverage plugin