minitest-given 0.1.pre → 3.0.0.beta.3

data/Rakefile

@@ -1,21 +1,231 @@
-require "rubygems"
-require "hoe"
+#!/usr/bin/ruby -wKU
 
-Hoe.plugin :gemspec
-Hoe.plugin :git
-Hoe.plugin :minitest
+require 'rake/clean'
+require './lib/given/version'
+require './lib/given/module_methods'
 
-Hoe.spec "minitest-given" do
-  developer "Mike Moore", "mike@blowmage.com"
+CLEAN.include("pkg/rspec-given-*").exclude("pkg/*.gem")
+CLOBBER.include("*.gemspec", "html", "README", "README.old")
 
-  self.summary     = "Given/When/Then for minitest"
-  self.description = "Adds Given/When/Then built on top of minitest's spec DSL."
-  self.urls        = ["http://blowmage.com/minitest-given"]
+# README Formatting --------------------------------------------------
 
-  self.history_file = "CHANGELOG.rdoc"
-  self.readme_file  = "README.rdoc"
-  self.testlib      = :minitest
+task :default => :examples
 
-  dependency "minitest", ">= 4.4.0"
-  dependency "wrong", ">= 0.6.3"
+def version
+  Given::VERSION
+end
+
+def tag_name
+  "rspec-given-#{version}"
+end
+
+def tagged?
+  `git tag`.split.include?(tag_name)
+end
+
+def git_clean?
+  sh "git status | grep 'nothing to commit'", :verbose => false do |status|
+    return status
+  end
+end
+
+desc "Display the current version tag"
+task :version do
+  puts tag_name
+end
+
+desc "Tag the current commit with #{tag_name}"
+task :tag do
+  fail "Cannot tag, project directory is not clean" unless git_clean?
+  fail "Cannot tag, #{tag_name} already exists." if tagged?
+  sh "git tag #{tag_name}"
+end
+
+# Running examples ---------------------------------------------------
+
+desc "Run all the examples"
+task :examples => [:specs, :rs_examples]
+
+desc "Run the RSpec 2 specs and examples"
+task :examples => [:specs, :rs_examples, :mt_examples]
+
+desc "Run the specs"
+task :specs do
+  puts "Running specs"
+  sh "rspec spec"
+end
+
+EXAMPLES = FileList['examples/**/*_spec.rb'].
+  exclude('examples/failing/*.rb').
+  exclude('examples/integration/failing/*.rb')
+
+unless Given::NATURAL_ASSERTIONS_SUPPORTED
+  EXAMPLES.exclude("examples/stack/*.rb")
+end
+
+FAILING_EXAMPLES = FileList['examples/failing/**/*_spec.rb']
+
+desc "Run the RSpec specs and examples"
+task :rs => [:specs, :rs_examples]
+
+desc "Run the Minitest tests and examples"
+task :mt => [:specs, :mt_examples]
+
+desc "Run the examples in RSpec 2"
+task :rs_examples => [:verify_rspec2] do
+  puts "Running examples (with RSpec2)"
+  sh "rspec #{EXAMPLES}"
+end
+
+desc "Run the examples in Minitest"
+task :mt_examples do
+  puts "Running examples (with Minitest)"
+  sh "ruby -Ilib:examples examples/loader.rb #{EXAMPLES}"
+end
+
+desc "Run failing examples"
+task :failing => [:verify_rspec2] do
+  puts "Running failing examples (with RSpec2)"
+  sh "rspec #{FAILING_EXAMPLES}"
+end
+
+task :verify_rspec1 do
+  sh "type spec >/dev/null 2>&1", :verbose => false do |status|
+    fail "You need to install RSpec 1 in order to test against it." unless status
+  end
+end
+
+task :verify_rspec2 do
+  sh "type rspec >/dev/null 2>&1", :verbose => false do |status|
+    fail "You need to install RSpec 2 in order to test against it." unless status
+  end
+end
+
+task :load_check do
+  SRC_FILES = FileList['lib/rspec/given/*.rb'].exclude(%r(rspec1))
+  SRC_FILES.each do |fn|
+    sh %{ruby -Ilib -e 'load "#{fn}"'}
+  end
+end
+
+# Formatting the README ----------------------------------------------
+
+directory 'html'
+
+desc "Display the README file"
+task :readme => ["README.md"] do
+  Bundler.with_clean_env do
+    sh "ghpreview README.md"
+  end
+end
+
+desc "Generate an RDoc README"
+file "README.md" => ["examples/stack/stack_spec.rb", "lib/given/version.rb"] do
+  open("README.md") do |ins|
+    open("README.tmp", "w") do |outs|
+      state = :copy
+      while line = ins.gets
+        case state
+        when :copy
+          if line =~ /rspec-given, version +\d+(\.(\d+|beta))+/i
+            line.gsub!(/version +\d+(\.(\d+|beta))+/i, "version #{Given::VERSION}")
+            outs.puts line
+          elsif line =~ /^<pre>/
+            state = :insert
+          else
+            outs.puts line
+          end
+        when :insert
+          outs.puts "<pre>"
+          outs.puts open("examples/stack/stack_spec.rb") { |codes| codes.read }
+          outs.puts "</pre>"
+          state = :skip
+        when :skip
+          state = :copy2 if line =~ /^<\/pre>/
+        when :copy2
+          outs.puts line
+        end
+      end
+    end
+  end
+  mv "README.md", "README.old"
+  mv "README.tmp", "README.md"
+end
+
+
+# RDoc ---------------------------------------------------------------
+begin
+  require 'rdoc/task'
+  if RDoc::VERSION > "2.4.2"
+    RDOC_ENABLED = true
+  else
+    puts "Version of RDoc is too old, please gem install a later version"
+    RDOC_ENABLED = false
+  end
+rescue LoadError => ex
+  RDOC_ENABLED = false
+end
+
+begin
+  require 'darkfish-rdoc'
+  DARKFISH_ENABLED = true
+rescue LoadError => ex
+  DARKFISH_ENABLED = false
+end
+
+if RDOC_ENABLED
+  def md_to_rdoc(infile, outfile)
+    open(infile) do |ins|
+      open(outfile, "w") do |outs|
+        state = :copy
+        while line = ins.gets
+          case state
+          when :ignore
+            if line =~ /^-->/
+              state = :copy
+            end
+          when :pre
+            if line =~ /^<\/pre>/
+              state = :copy
+            else
+              outs.puts "    #{line}"
+            end
+          when :copy
+            if line =~ /^<!--/
+              state = :ignore
+            elsif line =~ /^<pre>/
+              state = :pre
+            else
+              line.gsub!(/^####/, '====')
+              line.gsub!(/^###/, '===')
+              line.gsub!(/^##/, '==')
+              line.gsub!(/^#/, '=')
+              outs.puts line
+            end
+          end
+        end
+      end
+    end
+  end
+
+  file "README" => ["README.md"] do
+    md_to_rdoc("README.md", "README")
+  end
+
+  RDoc::Task.new("rdoc") do |rdoc|
+    rdoc.rdoc_dir = 'html'
+    rdoc.title    = "RSpec/Given -- A Given/When/Then extension for RSpec"
+    rdoc.options = [
+      '--line-numbers',
+      '--main' , 'doc/main.rdoc',
+      '--title', 'Given - Given/When/Then Extensions for RSpec'
+    ]
+    rdoc.options << '-SHN' << '-f' << 'darkfish' if DARKFISH_ENABLED
+
+    rdoc.rdoc_files.include('README')
+    rdoc.rdoc_files.include('MIT-LICENSE')
+    rdoc.rdoc_files.include('lib/**/*.rb', 'doc/**/*.rdoc')
+  end
+
+  task :rdoc => "README"
 end

data/TODO

@@ -0,0 +1,13 @@
+Things to do to improve the minitest integration
+
+TODO:
+
+* Make a separate gem for minitest (do we need one for given-core?)
+
+DONE:
+
+* Handle have_failed in minitest
+* General cleanup making sure files go where they need.
+* Implement assertion counting for minitest
+* Figure out why the minitest example count is so low.
+* Move stuff out of minitest_helper to appropriate file.

data/doc/main.rdoc

@@ -0,0 +1,7 @@
+= Given/When/Then for RSpec
+
+rspec-given is an RSpec extension to allow Given/When/Then notation in
+RSpec specifications.  It is a natural extension of the experimental
+work done on the Given framework.
+
+For more information see http://github.com/jimweirich/rspec-given

data/examples/example_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH << './examples/stack'
+
+if defined?(RSpec)
+  require 'rspec/given'
+  require 'spec_helper'
+else
+  require 'minitest/autorun'
+  require 'minitest/given'
+  require 'minitest_helper'
+end

data/examples/failing/natural_failing_spec.rb

@@ -0,0 +1,48 @@
+require 'rspec/given'
+require 'rspec/given/natural_assertion'
+
+describe "Natural Assertions" do
+  use_natural_assertions
+
+  Given(:foo) { 1 }
+  Given(:expected) { 2 }
+  Given(:ary) { [1] }
+  Given(:empty) { [] }
+  Given(:null) { nil }
+  Then { foo+foo+2*foo == expected }
+  Then { nil == "HI" && true && :symbol  && 1}
+  Then { foo.should == 2 }
+  Then { foo != 1 }
+  Then { foo.should_not == 1 }
+  Then { foo.should be_nil }
+  Then { ary.empty? }
+  Then { !null.nil? }
+  Then { fail "OUCH" }
+  Then { ! empty.empty? }
+  Then {
+    (puts "Ha ha world", ! true)
+  }
+
+  Then { Math.sqrt(10) == about(3.1623).percent(0.0001) }
+
+  describe "Error Examples" do
+    When(:result) { fail "OUCH" }
+    Then { result == :ok }
+  end
+
+  describe "Non-Error Failures" do
+    When(:result) { :ok }
+    Then { result == have_failed(StandardError, /^O/) }
+  end
+
+  context "Incorrect non-idempotent conditions" do
+    Given(:ary) { [1, 2, 3] }
+    Then { ary.delete(1) == nil }
+  end
+
+  context "Correct idempotent conditions" do
+    Given(:ary) { [1, 2, 3] }
+    When(:result) { ary.delete(1) }
+    Then { result == nil }
+  end
+end

data/examples/failing/sample_spec.rb

@@ -0,0 +1,7 @@
+require 'rspec/given'
+
+describe "Natural Assertions" do
+  Given(:foo) { 1 }
+  Given(:bar) { 2 }
+  Then { foo + bar == 2 }
+end

data/examples/integration/and_spec.rb

@@ -0,0 +1,44 @@
+require 'example_helper'
+
+describe "And" do
+
+  Given(:info) { [] }
+
+  describe "And is called after Then" do
+    Then { info << "T" }
+    And { info << "A" }
+    And { given_assert_equal ["T", "A"], info }
+  end
+
+  describe "And is called only once with multiple Thens" do
+    Then { info << "T" }
+    Then { info << "T2" }
+    And { given_assert(info == ["T"] || info == ["T2"]) }
+  end
+
+  describe "Inherited Ands are not run" do
+    Then { info << "T-OUTER" }
+    And { info << "A-OUTER" }
+    And { given_assert_equal ["T-OUTER", "A-OUTER"], info }
+
+    context "inner" do
+      Then { info << "T-INNER" }
+      And { info << "A-INNER" }
+      And { given_assert_equal ["T-INNER", "A-INNER"], info }
+    end
+  end
+
+  describe "Ands require a Then" do
+    begin
+      And { }
+    rescue StandardError => ex
+      @message = ex.message
+    end
+
+    it "should define a message" do
+      message = self.class.instance_eval { @message }
+      given_assert_match(/and.*without.*then/i, message)
+    end
+  end
+
+end

data/examples/integration/failing/eval_subexpression_spec.rb

@@ -0,0 +1,9 @@
+require 'rspec/given'
+
+describe "Then with nesting" do
+  use_natural_assertions
+  Given(:index) { 1 }
+  Given(:value) { "X" }
+  Given(:array) { ["a", "b", "c"] }
+  Then { array[index].upcase == value  }
+end

data/examples/integration/failing/module_nesting_spec.rb

@@ -0,0 +1,13 @@
+require 'rspec/given'
+
+module Nesting
+  X = 1
+end
+
+module Nesting
+  describe "Then with nesting" do
+    use_natural_assertions
+    Given(:z) { 2 }
+    Then { X == z }
+  end
+end

data/examples/integration/failing/undefined_method_spec.rb

@@ -0,0 +1,9 @@
+require 'rspec/given'
+
+describe "Then with nesting" do
+  use_natural_assertions
+  def self.xyz
+    nil
+  end
+  Then { xyz }
+end

data/examples/integration/failing_messages_spec.rb

@@ -0,0 +1,38 @@
+require 'example_helper'
+require 'open3'
+
+describe "Failing Messages" do
+  use_natural_assertions_if_supported
+
+  IOS = Struct.new(:out, :err)
+
+  def run_spec(filename)
+    inn, out, err, wait = Open3.popen3("rspec", "examples/integration/failing/#{filename}")
+    IOS.new(out.read, err.read)
+  end
+
+  When(:ios) { run_spec(failing_test) }
+
+  context "when referencing constants from nested modules" do
+    Given(:failing_test) { "module_nesting_spec.rb" }
+    Then { ios.err == "" }
+    And { ios.out !~ /uninitialized constant RSpec::Given::InstanceExtensions::X/ }
+  end
+
+  context "when referencing undefined methods" do
+    Given(:failing_test) { "undefined_method_spec.rb" }
+    Then { ios.err == "" }
+    And { ios.out =~ /undefined local variable or method `xyz'/ }
+  end
+
+  context "when breaking down expressions" do
+    Given(:failing_test) { "eval_subexpression_spec.rb" }
+    Then { ios.err == "" }
+    And  { ios.out =~ /false *<- array\[index\]\.upcase == value$/ }
+    And  { ios.out =~ /"B" *<- array\[index\].upcase$/ }
+    And  { ios.out =~ /"b" *<- array\[index\]$/ }
+    And  { ios.out =~ /\["a", "b", "c"\] *<- array$/ }
+    And  { ios.out =~ /1 *<- index$/ }
+    And  { ios.out =~ /"X" *<- value$/ }
+  end
+end

data/examples/integration/focused_line_spec.rb

@@ -0,0 +1,9 @@
+require 'example_helper'
+
+describe "Focused Line" do
+  it "runs only a single test" do
+    ENV['FRAMEWORK'] = nil
+    output = `rspec examples/other/line_example.rb:7`
+    given_assert_not_match(/FIRST/, output)
+  end
+end

data/examples/integration/given_spec.rb

@@ -0,0 +1,73 @@
+require 'example_helper'
+
+describe "Running Givens before Whens" do
+  Given(:info) { [] }
+  Given { info << "outer1" }
+  Given { info << "outer2" }
+
+  context "using a when without result" do
+    When { info << "when" }
+
+    context "inner with When" do
+      Given { info << "inner1" }
+      Given { info << "inner2" }
+      Then { given_assert_equal ["outer1", "outer2", "inner1", "inner2", "when"], info }
+
+      context "using a nested When" do
+        When { info << "when2" }
+        Then { given_assert_equal ["outer1", "outer2", "inner1", "inner2", "when", "when2"], info}
+      end
+
+      context "using two nested When" do
+        When { info << "when2a" }
+        When { info << "when2b" }
+        Then {
+          given_assert_equal ["outer1", "outer2", "inner1", "inner2", "when", "when2a", "when2b"], info
+        }
+      end
+    end
+  end
+
+  context "using a when with a result" do
+    When(:result) { info << "when" }
+
+    context "inner with when" do
+      Given { info << "inner1" }
+      Given { info << "inner2" }
+      Then { given_assert_equal ["outer1", "outer2", "inner1", "inner2", "when"], info }
+    end
+  end
+
+  context "using no whens" do
+    Given { info << "inner1" }
+    Given { info << "inner2" }
+    Then { given_assert_equal ["outer1", "outer2", "inner1", "inner2"], info }
+  end
+end
+
+describe "Lazy Givens" do
+  Given(:bomb) { fail StandardError, "SHOULD NEVER BE CALLED" }
+
+  context "when called" do
+    Then {
+      given_assert_raises(StandardError, /NEVER/) { bomb }
+    }
+  end
+
+  context "when not called" do
+    Given(:value) { :ok }
+    Then { given_assert_equal :ok, value }
+  end
+end
+
+describe "Non-Lazy Givens" do
+  Given(:info) { [] }
+
+  When { info << :when }
+
+  context "inner" do
+    Given!(:a) { info << :given; "A VALUE" }
+    Then { given_assert_equal [:given, :when], info }
+  end
+
+end

data/examples/integration/invariant_spec.rb

@@ -0,0 +1,31 @@
+require 'example_helper'
+
+describe "Invariants" do
+  Given(:info) { [] }
+
+  Invariant { info << "I1" }
+
+  Then { given_assert_equal ["I1"], info }
+
+  context "with nested invariants" do
+    Invariant { info << "I2" }
+
+    Then { given_assert_equal ["I1", "I2"], info }
+  end
+
+  context "with multiple invariants" do
+    Invariant { info << "I2a" }
+    Invariant { info << "I2b" }
+
+    Then { given_assert_equal ["I1", "I2a", "I2b"], info }
+  end
+
+  context "with a when" do
+    Invariant { info << "I2" }
+
+    When(:when_info) { info.dup }
+
+    Then { given_assert_equal ["I1", "I2"], info }
+    Then { given_assert_equal [], when_info }
+  end
+end

data/examples/integration/then_spec.rb

@@ -0,0 +1,8 @@
+require 'example_helper'
+
+describe "Then" do
+  context "empty thens with natural assertions" do
+    use_natural_assertions_if_supported
+    Then { }
+  end
+end

data/examples/loader.rb

@@ -0,0 +1,4 @@
+ARGV.each do |fn|
+  puts "Loading #{fn} ..."
+  load fn
+end

data/examples/minitest_helper.rb

@@ -0,0 +1,38 @@
+
+module GivenAssertions
+  def given_assert(cond)
+    assert cond
+  end
+
+  def given_assert_equal(expected, actual)
+    actual.must_equal(expected)
+  end
+
+  def given_assert_match(pattern, actual)
+    actual.must_match(pattern)
+  end
+
+  def given_assert_not_match(pattern, actual)
+    actual.wont_match(pattern)
+  end
+
+  def given_assert_raises(error, pattern=//, &block)
+    ex = assert_raises(error, &block)
+    ex.message.must_match(pattern)
+  end
+end
+
+module NaturalAssertionControl
+  def use_natural_assertions_if_supported(enabled=true)
+    if enabled && ! Given::NATURAL_ASSERTIONS_SUPPORTED
+      Given {
+        skip "Natural assertions are not supported in JRuby"
+      }
+    else
+      use_natural_assertions(enabled)
+    end
+  end
+end
+
+Minitest::Spec.send(:include, GivenAssertions)
+include NaturalAssertionControl

data/examples/other/line_example.rb

@@ -0,0 +1,9 @@
+require 'example_helper'
+
+describe "Line Spec" do
+
+  Then { puts "FIRST" }
+
+  Then { puts "SECOND" }
+
+end

data/examples/stack/stack.rb

@@ -0,0 +1,29 @@
+class Stack
+  class StackError < StandardError; end
+  class UnderflowError < StackError; end
+
+  def initialize
+    @items = []
+  end
+
+  def depth
+    @items.size
+  end
+
+  def empty?
+    @items.empty?
+  end
+
+  def top
+    @items.last
+  end
+
+  def push(item)
+    @items << item
+  end
+
+  def pop
+    fail UnderflowError, "Cannot pop an empty stack" if empty?
+    @items.pop
+  end
+end