mspec 1.0.0

data/spec/matchers/be_kind_of_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/expectations/expectations'
+require 'mspec/matchers/be_kind_of'
+
+describe BeKindOfMatcher do
+  it "matches when actual is a kind_of? expected" do
+    BeKindOfMatcher.new(Integer).matches?(1).should == true
+    BeKindOfMatcher.new(Fixnum).matches?(2).should == true
+    BeKindOfMatcher.new(Regexp).matches?(/m/).should == true
+  end
+
+  it "does not match when actual is not a kind_of? expected" do
+    BeKindOfMatcher.new(Integer).matches?(1.5).should == false
+    BeKindOfMatcher.new(String).matches?(:a).should == false
+    BeKindOfMatcher.new(Hash).matches?([]).should == false
+  end
+
+  it "provides a useful failure message" do
+    matcher = BeKindOfMatcher.new(Numeric)
+    matcher.matches?('string')
+    matcher.failure_message.should == ["Expected \"string\" (String)", "to be kind of Numeric"]
+  end
+
+  it "provides a useful negative failure message" do
+    matcher = BeKindOfMatcher.new(Numeric)
+    matcher.matches?(4.2)
+    matcher.negative_failure_message.should == ["Expected 4.2 (Float)", "not to be kind of Numeric"]
+  end
+end

data/spec/matchers/be_nil_spec.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/expectations/expectations'
+require 'mspec/matchers/be_nil'
+
+describe BeNilMatcher do
+  it "matches when actual is nil" do
+    BeNilMatcher.new.matches?(nil).should == true
+  end
+
+  it "does not match when actual is not nil" do
+    BeNilMatcher.new.matches?("").should == false
+    BeNilMatcher.new.matches?(false).should == false
+    BeNilMatcher.new.matches?(0).should == false
+  end
+
+  it "provides a useful failure message" do
+    matcher = BeNilMatcher.new
+    matcher.matches?("some string")
+    matcher.failure_message.should == ["Expected \"some string\"", "to be nil"]
+  end
+
+  it "provides a useful negative failure message" do
+    matcher = BeNilMatcher.new
+    matcher.matches?(nil)
+    matcher.negative_failure_message.should == ["Expected nil", "not to be nil"]
+  end
+end

data/spec/matchers/be_true_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/expectations/expectations'
+require 'mspec/matchers/be_true'
+
+describe BeTrueMatcher do
+  it "matches when actual is true" do
+    BeTrueMatcher.new.matches?(true).should == true
+  end
+
+  it "does not match when actual is not true" do
+    BeTrueMatcher.new.matches?("").should == false
+    BeTrueMatcher.new.matches?(false).should == false
+    BeTrueMatcher.new.matches?(nil).should == false
+    BeTrueMatcher.new.matches?(0).should == false
+  end
+
+  it "provides a useful failure message" do
+    matcher = BeTrueMatcher.new
+    matcher.matches?("some string")
+    matcher.failure_message.should == ["Expected \"some string\"", "to be true"]
+  end
+
+  it "provides a useful negative failure message" do
+    matcher = BeTrueMatcher.new
+    matcher.matches?(true)
+    matcher.negative_failure_message.should == ["Expected true", "not to be true"]
+  end
+end

data/spec/matchers/complain_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/expectations/expectations'
+require 'mspec/matchers/complain'
+
+describe ComplainMatcher do
+  it "matches when executing the proc results in output to $stderr" do
+    proc = lambda { warn "I'm gonna tell yo mama" }
+    ComplainMatcher.new(nil).matches?(proc).should == true
+  end
+
+  it "maches when executing the proc results in the expected output to $stderr" do
+    proc = lambda { warn "Que haces?" }
+    ComplainMatcher.new("Que haces?\n").matches?(proc).should == true
+    ComplainMatcher.new("Que pasa?\n").matches?(proc).should == false
+    ComplainMatcher.new(/Que/).matches?(proc).should == true
+    ComplainMatcher.new(/Quoi/).matches?(proc).should == false
+  end
+
+  it "does not match when there is no output to $stderr" do
+    ComplainMatcher.new(nil).matches?(lambda {}).should == false
+  end
+
+  it "provides a useful failure message" do
+    matcher = ComplainMatcher.new(nil)
+    matcher.matches?(lambda { })
+    matcher.failure_message.should == ["Expected a warning", "but received none"]
+    matcher = ComplainMatcher.new("listen here")
+    matcher.matches?(lambda { warn "look out" })
+    matcher.failure_message.should ==
+      ["Expected warning: \"listen here\"", "but got: \"look out\""]
+    matcher = ComplainMatcher.new(/talk/)
+    matcher.matches?(lambda { warn "listen up" })
+    matcher.failure_message.should ==
+      ["Expected warning to match:", "/talk/"]
+  end
+
+  it "provides a useful negative failure message" do
+    proc = lambda { warn "ouch" }
+    matcher = ComplainMatcher.new(nil)
+    matcher.matches?(proc)
+    matcher.negative_failure_message.should ==
+      ["Unexpected warning: ", "\"ouch\""]
+    matcher = ComplainMatcher.new("ouchy")
+    matcher.matches?(proc)
+    matcher.negative_failure_message.should ==
+      ["Expected warning: \"ouchy\"", "but got: \"ouch\""]
+    matcher = ComplainMatcher.new(/ou/)
+    matcher.matches?(proc)
+    matcher.negative_failure_message.should ==
+      ["Expected warning not to match:", "/ou/"]
+  end
+end

data/spec/matchers/eql_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/expectations/expectations'
+require 'mspec/matchers/eql'
+
+describe EqlMatcher do
+  it "matches when actual is eql? to expected" do
+    EqlMatcher.new(1).matches?(1).should == true
+    EqlMatcher.new(1.5).matches?(1.5).should == true
+    EqlMatcher.new("red").matches?("red").should == true
+    EqlMatcher.new(:blue).matches?(:blue).should == true
+    EqlMatcher.new(Object).matches?(Object).should == true
+
+    o = Object.new
+    EqlMatcher.new(o).matches?(o).should == true
+  end
+
+  it "does not match when actual is not eql? to expected" do
+    EqlMatcher.new(1).matches?(1.0).should == false
+    EqlMatcher.new(Hash).matches?(Object).should == false
+  end
+
+  it "provides a useful failure message" do
+    matcher = EqlMatcher.new("red")
+    matcher.matches?("red")
+    matcher.failure_message.should == ["Expected \"red\"", "to have same value and type as \"red\""]
+  end
+
+  it "provides a useful negative failure message" do
+    matcher = EqlMatcher.new(1)
+    matcher.matches?(1.0)
+    matcher.negative_failure_message.should == ["Expected 1.0", "not to have same value or type as 1"]
+  end
+end

data/spec/matchers/equal_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/expectations/expectations'
+require 'mspec/matchers/equal'
+
+describe EqualMatcher do
+  it "matches when actual is equal? to expected" do
+    EqualMatcher.new(1).matches?(1).should == true
+    EqualMatcher.new(:blue).matches?(:blue).should == true
+    EqualMatcher.new(Object).matches?(Object).should == true
+
+    o = Object.new
+    EqualMatcher.new(o).matches?(o).should == true
+  end
+
+  it "does not match when actual is not a equal? to expected" do
+    EqualMatcher.new(1).matches?(1.0).should == false
+    EqualMatcher.new(1.5).matches?(1.5).should == false
+    EqualMatcher.new("blue").matches?("blue").should == false
+    EqualMatcher.new(Hash).matches?(Object).should == false
+  end
+
+  it "provides a useful failure message" do
+    matcher = EqualMatcher.new("red")
+    matcher.matches?("red")
+    matcher.failure_message.should == ["Expected \"red\"", "to be identical to \"red\""]
+  end
+
+  it "provides a useful negative failure message" do
+    matcher = EqualMatcher.new(1)
+    matcher.matches?(1)
+    matcher.negative_failure_message.should == ["Expected 1", "not to be identical to 1"]
+  end
+end

data/spec/matchers/equal_utf16_spec.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/expectations/expectations'
+require 'mspec/matchers/equal_utf16'
+
+describe EqualUtf16Matcher do
+  it "when given strings, matches when actual == expected" do
+    EqualUtf16Matcher.new("abcd").matches?("abcd").should == true
+  end
+
+  it "when given strings, matches when actual == expected, with byte order reversed" do
+    EqualUtf16Matcher.new("abcd").matches?("badc").should == true
+  end
+
+  it "when given arrays, matches when actual == expected" do
+    EqualUtf16Matcher.new(["abcd"]).matches?(["abcd"]).should == true
+    EqualUtf16Matcher.new(["abcd", "efgh"]).matches?(["abcd", "efgh"]).should == true
+  end
+
+  it "when given arrays, matches when actual == a version of expected with byte order reversed for all strings contained" do
+    EqualUtf16Matcher.new(["abcd"]).matches?(["badc"]).should == true
+    EqualUtf16Matcher.new(["abcd", "efgh"]).matches?(["badc", "fehg"]).should == true
+  end
+
+  it "when given strings, does not match when actual != expected AND != expected with byte order reversed" do
+    EqualUtf16Matcher.new("abcd").matches?("").should == false
+    EqualUtf16Matcher.new("abcd").matches?(nil).should == false
+    EqualUtf16Matcher.new("abcd").matches?("acbd").should == false
+  end
+
+  it "when given arrays, does not match when actual is not == expected or == a version of expected with byte order reversed for all strings contained simultaneously" do
+    EqualUtf16Matcher.new(["abcd"]).matches?([]).should == false
+    EqualUtf16Matcher.new(["abcd"]).matches?(["dcba"]).should == false
+    EqualUtf16Matcher.new(["abcd", "efgh"]).matches?(["abcd", "fehg"]).should == false
+  end
+
+  it "provides a useful failure message" do
+    matcher = EqualUtf16Matcher.new("a\0b\0")
+    matcher.matches?("a\0b\0c\0")
+    matcher.failure_message.should == ["Expected \"a\\000b\\000c\\000\"", "to equal \"a\\000b\\000\" or \"\\000a\\000b\""]
+  end
+
+  it "provides a useful negative failure message" do
+    matcher = EqualUtf16Matcher.new("a\0b\0")
+    matcher.matches?("\0a\0b")
+    matcher.negative_failure_message.should == ["Expected \"\\000a\\000b\"", "not to equal \"a\\000b\\000\" nor \"\\000a\\000b\""]
+  end
+end

data/spec/matchers/include_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/expectations/expectations'
+require 'mspec/matchers/include'
+
+describe IncludeMatcher do
+  it "matches when actual includes expected" do
+    IncludeMatcher.new(2).matches?([1,2,3]).should == true
+    IncludeMatcher.new("b").matches?("abc").should == true
+  end
+
+  it "does not match when actual does not include expected" do
+    IncludeMatcher.new(4).matches?([1,2,3]).should == false
+    IncludeMatcher.new("d").matches?("abc").should == false
+  end
+
+  it "matches when actual includes all expected" do
+    IncludeMatcher.new(3, 2, 1).matches?([1,2,3]).should == true
+    IncludeMatcher.new("a", "b", "c").matches?("abc").should == true
+  end
+
+  it "does not match when actual does not include all expected" do
+    IncludeMatcher.new(3, 2, 4).matches?([1,2,3]).should == false
+    IncludeMatcher.new("a", "b", "c", "d").matches?("abc").should == false
+  end
+
+  it "provides a useful failure message" do
+    matcher = IncludeMatcher.new(5, 2)
+    matcher.matches?([1,2,3])
+    matcher.failure_message.should == ["Expected [1, 2, 3]", "to include 5"]
+  end
+
+  it "provides a useful negative failure message" do
+    matcher = IncludeMatcher.new(1, 2, 3)
+    matcher.matches?([1,2,3])
+    matcher.negative_failure_message.should == ["Expected [1, 2, 3]", "not to include 3"]
+  end
+end

data/spec/matchers/output_spec.rb

@@ -0,0 +1,74 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/expectations/expectations'
+require 'mspec/matchers/output'
+
+describe OutputMatcher do
+  it "matches when executing the proc results in the expected output to $stdout" do
+    proc = Proc.new { puts "bang!" }
+    OutputMatcher.new("bang!\n", nil).matches?(proc).should == true
+    OutputMatcher.new("pop", nil).matches?(proc).should == false
+    OutputMatcher.new(/bang/, nil).matches?(proc).should == true
+    OutputMatcher.new(/po/, nil).matches?(proc).should == false
+  end
+
+  it "matches when executing the proc results in the expected output to $stderr" do
+    proc = Proc.new { $stderr.write "boom!" }
+    OutputMatcher.new(nil, "boom!").matches?(proc).should == true
+    OutputMatcher.new(nil, "fizzle").matches?(proc).should == false
+    OutputMatcher.new(nil, /boom/).matches?(proc).should == true
+    OutputMatcher.new(nil, /fizzl/).matches?(proc).should == false
+  end
+
+  it "provides a useful failure message" do
+    proc = Proc.new { puts "unexpected"; $stderr.puts "unerror" }
+    matcher = OutputMatcher.new("expected", "error")
+    matcher.matches?(proc)
+    matcher.failure_message.should ==
+      ["Expected:\n  $stdout: \"expected\"\n  $stderr: \"error\"\n",
+       "     got:\n  $stdout: \"unexpected\"\n  $stderr: \"unerror\"\n"]
+    matcher = OutputMatcher.new("expected", nil)
+    matcher.matches?(proc)
+    matcher.failure_message.should ==
+      ["Expected:\n  $stdout: \"expected\"\n",
+       "     got:\n  $stdout: \"unexpected\"\n"]
+    matcher = OutputMatcher.new(nil, "error")
+    matcher.matches?(proc)
+    matcher.failure_message.should ==
+      ["Expected:\n  $stderr: \"error\"\n",
+       "     got:\n  $stderr: \"unerror\"\n"]
+    matcher = OutputMatcher.new(/base/, nil)
+    matcher.matches?(proc)
+    matcher.failure_message.should ==
+      ["Expected:\n  $stdout: /base/\n",
+       "     got:\n  $stdout: \"unexpected\"\n"]
+    matcher = OutputMatcher.new(nil, /octave/)
+    matcher.matches?(proc)
+    matcher.failure_message.should ==
+      ["Expected:\n  $stderr: /octave/\n",
+       "     got:\n  $stderr: \"unerror\"\n"]
+  end
+
+  it "provides a useful negative failure message" do
+    proc = Proc.new { puts "expected"; $stderr.puts "error" }
+    matcher = OutputMatcher.new("expected", "error")
+    matcher.matches?(proc)
+    matcher.negative_failure_message.should ==
+      ["Expected output not to be:\n", "  $stdout: \"expected\"\n  $stderr: \"error\"\n"]
+    matcher = OutputMatcher.new("expected", nil)
+    matcher.matches?(proc)
+    matcher.negative_failure_message.should ==
+      ["Expected output not to be:\n", "  $stdout: \"expected\"\n"]
+    matcher = OutputMatcher.new(nil, "error")
+    matcher.matches?(proc)
+    matcher.negative_failure_message.should ==
+      ["Expected output not to be:\n", "  $stderr: \"error\"\n"]
+    matcher = OutputMatcher.new(/expect/, nil)
+    matcher.matches?(proc)
+    matcher.negative_failure_message.should ==
+      ["Expected output not to be:\n", "  $stdout: \"expected\"\n"]
+    matcher = OutputMatcher.new(nil, /err/)
+    matcher.matches?(proc)
+    matcher.negative_failure_message.should ==
+      ["Expected output not to be:\n", "  $stderr: \"error\"\n"]
+  end
+end

data/spec/matchers/output_to_fd_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/expectations/expectations'
+require 'mspec/matchers/output_to_fd'
+
+describe OutputToFDMatcher do
+  # Figure out how in the hell to achieve this
+  it "matches when running the block produces the expected output to the given FD" do
+    output_to_fd("Hi\n", STDERR).matches?(lambda { $stderr.print "Hi\n" }).should == true
+  end
+
+  it "does not match if running the block does not produce the expected output to the FD" do
+    output_to_fd("Hi\n", STDERR).matches?(lambda { $stderr.puts("Hello\n") }).should == false
+  end
+
+  it "defaults to matching against STDOUT" do
+    output_to_fd("Hi\n").matches?(lambda { $stdout.print "Hi\n" }).should == true
+  end
+
+  it "accepts any IO instance" do
+    io = IO.new STDOUT.fileno
+    output_to_fd("Hi\n", io).matches?(lambda { io.print "Hi\n" }).should == true
+  end
+
+  it "allows matching with a Regexp" do
+    s = "Hi there\n"
+    output_to_fd(/Hi/, STDERR).matches?(lambda { $stderr.print s }).should == true
+    output_to_fd(/Hi?/, STDERR).matches?(lambda { $stderr.print s }).should == true
+    output_to_fd(/[hH]i?/, STDERR).matches?(lambda { $stderr.print s }).should == true
+    output_to_fd(/.*/, STDERR).matches?(lambda { $stderr.print s }).should == true
+    output_to_fd(/H.*?here/, STDERR).matches?(lambda { $stderr.print s }).should == true
+    output_to_fd(/Ahoy/, STDERR).matches?(lambda { $stderr.print s }).should == false
+  end
+end

data/spec/matchers/raise_error_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'mspec/expectations/expectations'
+require 'mspec/matchers/raise_error'
+
+class ExpectedException < Exception; end
+class UnexpectedException < Exception; end
+
+describe RaiseErrorMatcher do
+  it "matches when the proc raises the expected exception" do
+    proc = Proc.new { raise ExpectedException }
+    RaiseErrorMatcher.new(ExpectedException, nil).matches?(proc).should == true
+  end
+
+  it "executes it's optional block if matched" do
+    run = false
+    proc = Proc.new { raise ExpectedException }
+    matcher = RaiseErrorMatcher.new(ExpectedException, nil) { |error|
+      run = true
+      error.class.should == ExpectedException
+    }
+
+    matcher.matches?(proc).should == true
+    run.should == true
+  end
+
+  it "matches when the proc raises the expected exception with the expected message" do
+    proc = Proc.new { raise ExpectedException, "message" }
+    RaiseErrorMatcher.new(ExpectedException, "message").matches?(proc).should == true
+  end
+
+  it "does not match when the proc does not raise the expected exception" do
+    proc = Proc.new { raise UnexpectedException }
+    RaiseErrorMatcher.new(ExpectedException, nil).matches?(proc).should == false
+  end
+
+  it "does not match when the proc raises the expected exception with an unexpected message" do
+    proc = Proc.new { raise UnexpectedException, "unexpected" }
+    RaiseErrorMatcher.new(ExpectedException, "expected").matches?(proc).should == false
+  end
+
+  it "provides a useful failure message" do
+    proc = Proc.new { raise UnexpectedException, "unexpected" }
+    matcher = RaiseErrorMatcher.new(ExpectedException, "expected")
+    matcher.matches?(proc)
+    matcher.failure_message.should ==
+      ["Expected ExpectedException (expected)", "but got UnexpectedException (unexpected)"]
+  end
+
+  it "provides a useful negative failure message" do
+    proc = Proc.new { raise ExpectedException, "expected" }
+    matcher = RaiseErrorMatcher.new(ExpectedException, "expected")
+    matcher.matches?(proc)
+    matcher.negative_failure_message.should ==
+      ["Expected to not get ExpectedException (expected)", ""]
+  end
+end