compact 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e745ded7faf0e81a41da4cbf2f34c819e470a0eb
+  data.tar.gz: 48c7298e8e94f77d0bf1f3c393babe9153d4cda8
+SHA512:
+  metadata.gz: e05392644bf09d4c61199c702a957a023ab5cc293ac7dd50c34d66d8590c3a0c280f936f934a7417f56d54826416f7ff9bc2e9a0f64b90f3ffe0683e3d55b48d
+  data.tar.gz: 749f4b24a836dcac3e77badbe97867cab45a354b5a1511f47657e203a97115abc8dedf8844252756aa1e22be473a82252d0ccf51808917495bd71331462e90e6

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.ruby-gemset

@@ -0,0 +1 @@
+compact

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.5.0

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 2.0.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,75 @@
+# Contributor Covenant Code of Conduct
+TL;DR: MINSWAN.
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at rold9888@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in compact.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,30 @@
+PATH
+  remote: .
+  specs:
+    compact (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    docile (1.3.2)
+    minitest (5.14.0)
+    mocha (1.11.2)
+    rake (13.0.1)
+    simplecov (0.18.5)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+    simplecov-html (0.12.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  compact!
+  minitest (~> 5.0)
+  mocha (~> 1.11)
+  rake (~> 13.0)
+  simplecov (~> 0.18)
+
+BUNDLED WITH
+   2.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Rob
+
+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,301 @@
+# COMPACT: COMPrehensive Automated Contract Testing
+
+
+>noun: __compact__
+>
+> *a formal agreement or contract between two or more parties.*
+
+_Because lots of the PACT - based names were taken_
+## Motivation
+This library aims to help you combat the problem of drifting test doubles: 
+if you change the behaviour of a class upon which other classes depend, and 
+you unit test those classes using test doubles in place of the real thing, 
+then you run the risk of testing your classes against the old behaviour of 
+their dependencies. (Note that this is distinct from the idea of contract tests 
+against remote services.)
+
+The traditional approach to guarding against this problem is to complement 
+unit tests with integration tests. But Joe Rainsberger would have us believe 
+that 
+[integration tests are a scam](https://www.infoq.com/presentations/integration-tests-scam/),
+and that there are real advantages to verifying the basic correctness of our code with 
+[contract tests](https://blog.thecodewhisperer.com/permalink/getting-started-with-contract-tests) instead.
+
+To take a concrete example, let's think about a `Calculator` class that delegates 
+responsibility for individual arithmetic operations to classes such as `Adder`. A 
+collaboration test looks like
+
+```ruby
+class CalculatorTest < MiniTest::Test
+  def test_addition_collaboration
+    adder = Minitest::Mock.new
+    adder.expect(:add,3,[1,2])
+    subject = Calculator.new(adder, *other_dependencies)
+    assert_equal 3, subject.add(1,2)
+  end
+  #...
+end 
+```
+
+To ensure that the expected behaviour of our mock reflects the actual behaviour of our
+code, we write a corresponding contract test for the `Adder` class:
+
+```ruby
+class AdderTest < MiniTest::Test
+  def test_addition_contract
+    subject = Adder.new
+    assert_equal 3, subject.add(1,2)
+  end
+end
+```
+
+Note the correspondence between the supplied arguments and the return values of the `Adder#add`
+method in these tests.
+
+Maintaining this correspondence by hand requires discipline. It becomes significantly harder on 
+a team of developers. This gem helps to seek automate maintaining this correspondence.
+
+## Design goals
+#### Library agnostic
+Whereas some previous steps in this direction have been integrated into specific testing/mocking
+libraries such as 
+[Bogus](https://relishapp.com/bogus/bogus/v/0-1-6/docs/contract-tests), 
+this aims to be something you can drop into an existing test suite and make it immediately more 
+robust, whatever test suite or test double library you are using. 
+(We're not there yet: see below for the current status.) 
+
+#### Mock roles, not objects
+The correspondence between test doubles and objects that fulfill those roles is to be labelled by the
+programmer, rather than tied to specific classes.
+
+#### Verify behaviour, not just syntax
+It also aims to go one step further than most other such libraries in trying to maintain the 
+correspondence between inputs and return values, whereas something like 
+[RSpec's verifying doubles](https://relishapp.com/rspec/rspec-mocks/docs/verifying-doubles)
+just verify that a stubbed method is present on some class.
+
+## Usage
+To record the contracts defined by a test double, prepare the double as you normally would but 
+inside a block passed to `Compact.prepare_double(role_name)`:
+
+```ruby
+class CalculatorTest < MiniTest::Test
+  def test_addition_collaboration
+    adder = Compact.prepare_double('adder') do
+      mock = Minitest::Mock.new
+      mock.expect(:add,3,[1,2])
+      mock
+    end 
+    subject = Calculator.new(adder, *other_dependencies)
+    assert_equal 3, subject.add(1,2)
+  end
+  #...
+end 
+```
+
+This method wraps the return value of the block with a simple decorator that tracks the methods 
+dispatched to that double, the arguments with which they are invoked, and the returned values.
+It stores these in some state that persists across test runs to produce a summary report at the
+end of your test run.
+
+The corresponding enhancement to the contract test is achieved by the method 
+`Compact.verify_contract(role_name, object_that_fulfills_role)`. Passing a block to this method in which 
+a stubbed method is invoked with the appropriate arguments and returns the correct value verifies 
+the contract.
+
+```ruby
+class AdderTest < MiniTest::Test
+  def test_addition_contract
+    adder = Adder.new
+    Compact.verify_contract('adder', adder){|adder| assert_equal 3, adder.add(1,2) }
+  end
+end
+```
+
+A contract can fail to be verified in three ways: 
+
+1. A missing contract test
+2. A verified method not being asserted by some test_double. 
+3. A mismatch in the behaviour of a double and real object intended to fulfill its role.
+
+At the end of your test run Compact will alert you to any instances of all three of these
+cases. See the next section for an example.
+
+## A complete example
+An executable version of this can be found in `/examples`, and run with `rake examples`. 
+Note that the contract tests would normally be written against the classes such as `Adder`
+etc. but are interleaved with the collaboration tests in this example to highlight the 
+correspondences.
+
+```ruby
+require "compact"
+
+# The calculator class delegates its difficult arithmetic
+# work to four service classes.
+#
+# Addition provides a happy example of contract validation.
+# Subtraction has a collaboration test without a contract test.
+# Multiplication is a collaborator in search of a collaboration.
+# Division tells the unhappy story of a soul who's confused about
+# whether they want integer or floating point division.
+class CalculatorTest < MiniTest::Test
+
+  def test_addition_collaboration
+    adder = Compact.prepare_double('adder') do
+      adder = Minitest::Mock.new
+      adder.expect(:add,3,[1,2])
+    end
+
+    subject = Calculator.new(adder, nil, nil, nil)
+    subject.add(1,2)
+  end
+
+  def test_addition_contract
+    adder = Adder.new
+    Compact.verify_contract('adder', adder){|adder| assert_equal 3, adder.add(1,2) }
+  end
+
+  # NO subtraction contract test!
+  def test_subtraction_collaboration
+    subtracter = Compact.prepare_double('subtracter') do
+      subtracter = Minitest::Mock.new
+      subtracter.expect(:subtract,5,[7,2])
+    end
+
+    subject = Calculator.new(nil, subtracter, nil, nil)
+    subject.subtract(7,2)
+  end
+
+  # NO multiplication collaboration test!
+  def test_multiplication_contract
+    multiplier = Multiplier.new
+    Compact.verify_contract('multiplier', multiplier) do |multiplier|
+      assert_equal 6, multiplier.multiply(2,3)
+    end
+  end
+
+  def test_division_collaboration
+    divider = Compact.prepare_double('divider') do
+      mock = Minitest::Mock.new
+      mock.expect(:divide,2.5,[5,2])
+    end
+
+    subject = Calculator.new(nil, nil, nil, divider)
+    subject.divide(5,2)
+  end
+
+  # Mismatched assertion
+  def test_division_contract
+    divider = Divider.new
+    Compact.verify_contract('divider', divider){|divider| assert_equal 2, divider.divide(5,2) }
+  end
+
+end
+
+```
+
+Running this (`rake examples`) produces the following report:
+
+```
+The following contracts could not be verified:
+Role Name: subtracter
+The following methods were invoked on test doubles without corresponding contract tests:
+================================================================================
+method: subtract
+invoke with: [7, 2]
+returns: 5
+================================================================================
+Role Name: multiplier
+No test doubles mirror the following verified invocations:
+================================================================================
+method: multiply
+invoke with: [2, 3]
+returns: 6
+================================================================================
+Role Name: divider
+Attempts to verify the following method invocations failed:
+================================================================================
+method: divide
+invoke with: [5, 2]
+expected: 2.5
+Matching invocations returned the following values: [2]
+================================================================================
+```
+
+## Status
+My goals in sharing this publicly at this early stage are:
+
+* To gauge interest in the idea
+* To get feedback on the API
+* To solicit anyone's input on some areas for further development below.
+
+In version 0.1.0, "Comprehensive" should be understood as an aspiration rather than 
+a promise. In particular, I've only written a reporter for Minitest. RSpec is next on the agenda.
+Tests have however been written against doubles created using Minitest::Mock, Mocha and `Object.new`. 
+
+And at the risk of stating the obvious, please do not rely on (version 0.1.0 of) this library to prove the basic correctness
+of your safety-critical nuclear-powered aerospace software.
+
+Of more pressing concern are some conceptual questions. 
+
+#### Mocks vs stubs
+At present the design is clearly skewed towards verifying stubs - i.e. test doubles whose purpose is to 
+return a canned value. Matching on return values is a key part of the current verification. We use mocks 
+instead if we want to assert that some method is called for its side effects. In Java we would likely be 
+able to rely on both mocked and real methods having `void` return signature, but in Ruby we have implicit
+returns and all bets are off. This probably motivates the introduction of some less stringent addition to 
+the Compact API that fulfills criteria similar to a verifying double.
+
+#### Dependency Injection
+This design relies on being able to create an instance of a test double and inject it as a dependency to the subject 
+of your collaboration test. Some more sophisticated mocking libraries offer ways in which you can use mocks 
+in ways that do not meet this requirement (such as mocking static factory methods). We can't help with that.
+
+#### Class methods
+This really generalises the above point. The current API depends crucially on being able to decorate instances
+of your test double. I've tried implementations that redefine methods, and they work on a simple `Object.new` stub, 
+but instantly explode when you call `test_double.method` on a Minitest mock that isn't expecting to receive `:method`. 
+(Minitest::Mock doesn't actually support mocking class methods anyway as far as I am aware.) But it seems like any 
+solution to this problem will necessarily require a compromise on the goal of being agnostic about your other tools.
+
+#### Value Objects in method invocations 
+The examples above all use integers as the method arguments and return values. When verifying contracts method 
+arguments and return values are compared using `==`. It's not clear to me how this approach can be generalised 
+to include parameters that are not value objects.
+
+## Installation
+I mean ... it's a gem. 
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'compact'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install compact
+
+
+## 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/robwold/compact. 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).
+
+## Code of Conduct
+
+Everyone interacting in the Compact project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the 
+[code of conduct](https://github.com/robwold/compact/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,24 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "rdoc/task"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+Rake::TestTask.new(:examples) do |t|
+  t.libs << "examples"
+  #t.libs << "lib" # uncomment for local development without the gem installed.
+  t.test_files = FileList["examples/test/*_test.rb"]
+end
+
+Rake::RDocTask.new do |rdoc|
+  files = ['README.md', 'LICENSE.txt', 'lib/']
+  rdoc.rdoc_files.add(files)
+  rdoc.rdoc_dir = "doc"
+  rdoc.main = "README.md" # page to start on
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "compact"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/compact.gemspec

@@ -0,0 +1,36 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "compact/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "compact"
+  spec.version       = Compact::VERSION
+  spec.authors       = ["Rob"]
+  spec.email         = ["rold9888@gmail.com"]
+
+  spec.summary       = %q{Comprehensive Automated Contract Testing.}
+  spec.description   = %q{Aims to help you keep the behaviour of your test doubles in line with that of your real dependencies.}
+  spec.homepage      = "https://github.com/robwold/compact"
+  spec.license       = "MIT"
+
+  #spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  #spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|examples)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "simplecov", "~>0.18"
+  spec.add_development_dependency "mocha", "~>1.11"
+end

data/lib/compact.rb

@@ -0,0 +1,55 @@
+require "compact/version"
+require 'compact/contract'
+require 'compact/ledger'
+require 'compact/verification_codes'
+
+#
+# This TOP-level module defines the entire public API of the gem.
+#
+module Compact
+  @@ledger = Ledger.new
+
+  # To record the interactions of your test_double,
+  # prepare inside a block passed to this method.
+  # Give the role played by the mock a name so we can
+  # cross-reference it with tests against the real
+  # implementation.
+  #
+  #   my_watched_mock = Compact.prepare_double('role_name') do
+  #     mock = MyMock.new
+  #     mock.expect(:method_name, return_args, when_called_with)
+  #   end
+  #
+  # The returned mock is decorated with an +ArgumentInterceptor+ that records:
+  # - methods sent to it
+  # - the arguments with which they were called
+  # - and the return values
+  # and stores these +Invocation+s in an instance of the +Ledger+ class for comparison
+  # with the corresponding contract tests in +verify_contract+.
+  def self.prepare_double(name, block = Proc.new)
+    @@ledger.prepare_double(name, block)
+  end
+
+  # Calling this method checks that the +collaborator+ param is
+  # an object capable of fulfilling the role defined by +name+
+  # (for which see +prepare_double+).
+  #
+  # Example usage:
+  #
+  #   Compact.verify_contract('role_name', myObject) do
+  #     expected = return_value
+  #     actual =  myObject.method_name(*args_specified_by_test_double)
+  #     assert_equal expected, actual
+  #   end
+  #
+  def self.verify_contract(name, collaborator, block = Proc.new )
+    @@ledger.verify_contract(name, collaborator, block)
+  end
+
+  # Unlikely to be used by end users of this gem.
+  # Used to write test reporters that give us the low-down at the end of our suite.
+  def self.summary
+    @@ledger.summary
+  end
+
+end

data/lib/compact/argument_interceptor.rb

@@ -0,0 +1,23 @@
+module Compact
+  class ArgumentInterceptor < SimpleDelegator
+    attr_accessor :invocations
+
+    def initialize(delegate)
+      @invocations = []
+      @contract = nil
+      super
+    end
+
+    def register(contract)
+      @contract = contract
+    end
+
+    def method_missing(method, *args, &block)
+      returns = super
+      invocation = Invocation.new(method: method, args: args, returns: returns)
+      @invocations.push(invocation)
+      @contract.add_invocation(invocation) if @contract
+      returns
+    end
+  end
+end

data/lib/compact/contract.rb

@@ -0,0 +1,104 @@
+require_relative './argument_interceptor'
+require_relative './invocation'
+require 'set'
+module Compact
+  class Contract
+    attr_reader :specs
+
+    def initialize
+      @collaborator_invocations = Set.new
+      @test_double_invocations = Set.new
+    end
+
+    def prepare_double(block = Proc.new)
+      double = block.call
+      interceptor = ArgumentInterceptor.new(double)
+      interceptor.register(self)
+      interceptor
+    end
+
+    def verified?
+      @test_double_invocations == @collaborator_invocations
+    end
+
+    def has_pending?
+      !pending_invocations.empty?
+    end
+
+    def has_untested?
+      !untested_invocations.empty?
+    end
+
+    def has_failing?
+      !failing_invocations.empty?
+    end
+
+    def describe_untested_specs
+      headline = "The following methods were invoked on test doubles without corresponding contract tests:"
+      messages = untested_invocations.map(&:describe)
+      print_banner_separated(headline, messages)
+    end
+
+    def describe_pending_specs
+      headline = "No test doubles mirror the following verified invocations:"
+      messages = pending_invocations.map(&:describe)
+      print_banner_separated(headline, messages)
+    end
+
+    def describe_failing_specs
+      headline = "Attempts to verify the following method invocations failed:"
+      messages = failing_invocations.map do |invocation|
+        bad_results = unspecified_invocations.select{|p| p.matches_call(invocation) }
+        invocation.describe.gsub("returns", "expected") +
+            "\nMatching invocations returned the following values: #{bad_results.map(&:returns).inspect}"
+      end
+      print_banner_separated(headline, messages)
+    end
+
+    def verify(collaborator, block = Proc.new)
+      interceptor = ArgumentInterceptor.new(collaborator)
+      block.call(interceptor)
+      interceptor.invocations.each{|inv| @collaborator_invocations.add(inv) }
+    end
+
+    def add_invocation(invocation)
+      @test_double_invocations.add(invocation)
+    end
+
+    private
+
+    def untested_invocations
+      uncorroborated_invocations - failing_invocations
+    end
+
+    def pending_invocations
+      unspecified_invocations.reject do |inv|
+        failing_invocations.any? {|failure| inv.matches_call(failure)}
+      end
+    end
+
+    def uncorroborated_invocations
+      (@test_double_invocations - @collaborator_invocations).to_a
+    end
+
+    def unspecified_invocations
+      (@collaborator_invocations - @test_double_invocations).to_a
+    end
+
+    def failing_invocations
+      uncorroborated_invocations.select do |spec|
+        unspecified_invocations.any?{|inv| inv.matches_call(spec)}
+      end
+    end
+
+    def print_banner_separated(headline, messages)
+      banner = "================================================================================"
+      <<~MSG
+      #{headline}
+      #{banner}
+      #{messages.join(banner).strip}
+      #{banner}
+      MSG
+    end
+  end
+end

data/lib/compact/invocation.rb

@@ -0,0 +1,37 @@
+module Compact
+  class Invocation
+    attr_reader :method, :args, :returns
+    def initialize( method:, args:,  returns:)
+      @method = method
+      @args = args
+      @returns = returns
+    end
+
+    def == other_invocation
+      same_returns = returns == other_invocation.returns
+      matches_call(other_invocation) && same_returns
+    end
+
+    def eql? other_invocation
+      self.== other_invocation
+    end
+
+    def hash
+      describe.hash
+    end
+
+    def matches_call(other_invocation)
+      same_args = args == other_invocation.args
+      same_method = method == other_invocation.method
+      same_args && same_method
+    end
+
+    def describe
+      <<~DESCRIPTION
+      method: #{method}
+      invoke with: #{args.inspect}
+      returns: #{returns}
+      DESCRIPTION
+    end
+  end
+end

data/lib/compact/ledger.rb

@@ -0,0 +1,64 @@
+module Compact
+  class Ledger
+
+    def initialize
+      @contracts = {}
+    end
+
+    def prepare_double(name, block = Proc.new)
+      @contracts[name] ||= Contract.new
+      contract = @contracts[name]
+      contract.prepare_double(block)
+    end
+
+    # deprecate this?
+    def record_contract(name, test_double, methods_to_watch = [])
+      @contracts[name] ||= Contract.new
+      contract = @contracts[name]
+      contract.watch(test_double, methods_to_watch)
+    end
+
+    def verify_contract(name, collaborator, block = Proc.new )
+      @contracts[name] ||= Contract.new
+      contract = @contracts[name]
+      contract.verify(collaborator, block)
+    end
+
+    def summary
+      unverified_contracts = []
+      @contracts.each do |name, contract|
+        unverified_contracts << contract unless contract.verified?
+      end
+      if unverified_contracts.empty?
+        'All test double contracts are satisfied.'
+      else
+        msg = <<~EOF
+        The following contracts could not be verified:
+        #{summarise_untested_contracts}
+        #{summarise_pending_contracts}
+        #{summarise_failing_contracts}
+        EOF
+        msg.gsub(/\n+/, "\n")
+      end
+    end
+
+    private
+
+    # If the metaprogramming gets clunky to work with here git can help you out with
+    # some explicit, repetitive definitions.
+    [:untested, :pending, :failing].each do |category|
+      method_name = "summarise_#{category}_contracts"
+      test_for_presence = "has_#{category}?"
+      describe_category_specs = "describe_#{category}_specs"
+      define_method(method_name) do
+        return nil unless @contracts.values.any?{|c| c.send(test_for_presence) }
+        summary = ""
+        @contracts.each do |name, contract|
+          summary += "Role Name: #{name}\n#{contract.send(describe_category_specs)}" if contract.send(test_for_presence)
+        end
+        summary.strip
+      end
+    end
+
+  end
+end

data/lib/compact/verification_codes.rb

@@ -0,0 +1,6 @@
+module Compact
+  PENDING = :pending
+  VERIFIED = :verified
+  FAILING = :failing
+  UNTESTED = :untested
+end

data/lib/compact/version.rb

@@ -0,0 +1,3 @@
+module Compact
+  VERSION = "0.1.0"
+end

data/lib/minitest/compact_plugin.rb

@@ -0,0 +1,9 @@
+require_relative './compact_reporter'
+module Minitest
+  def self.plugin_compact_options(opts, options) ; end
+
+
+  def self.plugin_compact_init(options)
+    self.reporter << CompactReporter.new
+  end
+end

data/lib/minitest/compact_reporter.rb

@@ -0,0 +1,11 @@
+require_relative '../compact/ledger'
+module Minitest
+  class CompactReporter < AbstractReporter
+
+    def record(result); end
+
+    def report
+      puts Compact.summary
+    end
+  end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: compact
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rob
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+description: Aims to help you keep the behaviour of your test doubles in line with
+  that of your real dependencies.
+email:
+- rold9888@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- compact.gemspec
+- lib/compact.rb
+- lib/compact/argument_interceptor.rb
+- lib/compact/contract.rb
+- lib/compact/invocation.rb
+- lib/compact/ledger.rb
+- lib/compact/verification_codes.rb
+- lib/compact/version.rb
+- lib/minitest/compact_plugin.rb
+- lib/minitest/compact_reporter.rb
+homepage: https://github.com/robwold/compact
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/robwold/compact
+  source_code_uri: https://github.com/robwold/compact
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Comprehensive Automated Contract Testing.
+test_files: []