minispec 0.0.1

data/test/test__before_and_after.rb

@@ -0,0 +1,117 @@
+class MinispecTest
+  class Hooks < self
+
+    BEFORE, AFTER = {}, {}
+    EXPECTED = {
+      [:*] => [:jazz, :blues, :rhythm_and_blues],
+      jazz: [[:*], [:jazz]],
+      blues: [[:*], [/blues/], [/blues/, {:except=>/rhythm/}]],
+      rhythm_and_blues: [[:*], [/blues/]]
+    }.freeze
+
+    class Before
+      include Minispec
+
+      before do |test, matcher|
+        update_status(test, matcher)
+        update_status(matcher, test)
+      end
+
+      before :jazz do |test, matcher|
+        update_status(test, matcher)
+      end
+
+      before /blues/ do |test, matcher|
+        update_status(test, matcher)
+      end
+
+      before /blues/, except: /rhythm/ do |test, matcher|
+        update_status(test, matcher)
+      end
+
+      test :jazz do
+      end
+
+      test :blues do
+      end
+
+      test :rhythm_and_blues do
+      end
+
+      private
+      def update_status test, matcher
+        (BEFORE[test] ||= []).push(matcher)
+      end
+    end
+    msrun(Before)
+
+    class After
+      include Minispec
+
+      after do |test, matcher|
+        update_status(test, matcher)
+        update_status(matcher, test)
+      end
+
+      after :jazz do |test, matcher|
+        update_status(test, matcher)
+      end
+
+      after /blues/ do |test, matcher|
+        update_status(test, matcher)
+      end
+
+      after /blues/, except: /rhythm/ do |test, matcher|
+        update_status(test, matcher)
+      end
+
+      test :jazz do
+      end
+
+      test :blues do
+      end
+
+      test :rhythm_and_blues do
+      end
+
+      private
+      def update_status test, matcher
+        (AFTER[test] ||= []).push(matcher)
+      end
+    end
+    msrun(After)
+
+    def test_before_any
+      assert_equal BEFORE[[:*]], EXPECTED[[:*]]
+    end
+
+    def test_after_any
+      assert_equal AFTER[[:*]], EXPECTED[[:*]]
+    end
+
+    def test_before_jazz
+      assert_equal BEFORE[:jazz], EXPECTED[:jazz]
+    end
+
+    def test_after_jazz
+      assert_equal AFTER[:jazz], EXPECTED[:jazz]
+    end
+
+    def test_before_blues
+      assert_equal BEFORE[:blues], EXPECTED[:blues]
+    end
+
+    def test_after_blues
+      assert_equal AFTER[:blues], EXPECTED[:blues]
+    end
+
+    def test_before_rhythm_and_blues
+      assert_equal BEFORE[:rhythm_and_blues], EXPECTED[:rhythm_and_blues]
+    end
+
+    def test_after_rhythm_and_blues
+      assert_equal AFTER[:rhythm_and_blues], EXPECTED[:rhythm_and_blues]
+    end
+
+  end
+end

data/test/test__before_and_after_all.rb

@@ -0,0 +1,71 @@
+class MinispecTest
+  class BeforeAllTest < self
+
+    X, Y = [], []
+    module BeforeAll
+      include Minispec
+
+      before_all do
+        X << self.class
+      end
+    end
+
+    class BeforeAllInherited
+      include BeforeAll
+    end
+
+    def test_inherited_boot
+      msrun(BeforeAllInherited)
+      assert X.include?(BeforeAllInherited)
+    end
+
+    class BeforeAllInheritedAndOverriden
+      include BeforeAll
+
+      before_all do
+        Y << self.class
+      end
+    end
+
+    def test_override_inherited_boot
+      msrun(BeforeAllInheritedAndOverriden)
+      refute X.include?(BeforeAllInheritedAndOverriden)
+      assert Y.include?(BeforeAllInheritedAndOverriden)
+    end
+  end
+
+  class AfterAllTest < self
+
+    X, Y = [], []
+    module AfterAll
+      include Minispec
+
+      after_all do
+        X << self.class
+      end
+    end
+
+    class AfterAllInherited
+      include AfterAll
+    end
+
+    def test_inherited_after_all
+      msrun(AfterAllInherited)
+      assert X.include?(AfterAllInherited)
+    end
+
+    class AfterAllInheritedAndOverriden
+      include AfterAll
+
+      after_all do
+        Y << self.class
+      end
+    end
+
+    def test_override_inherited_after_all
+      msrun(AfterAllInheritedAndOverriden)
+      refute X.include?(AfterAllInheritedAndOverriden)
+      assert Y.include?(AfterAllInheritedAndOverriden)
+    end
+  end
+end

data/test/test__helpers.rb

@@ -0,0 +1,197 @@
+class MinispecTest
+  class Helpers < self
+
+    class TrueTest
+      include Minispec
+
+      testing :true? do
+        is(true).true?
+      end
+      should ':fail' do
+        is(:blah).true?
+      end
+    end
+    define_tests(TrueTest)
+
+    class PositiveTest
+      include Minispec
+
+      testing :positive? do
+        is(true).positive?
+        is(:something).positive?
+        is('anything').positive?
+      end
+      should ':fail when nil' do
+        is(nil).positive?
+      end
+      should ':fail when false' do
+        is(false).positive?
+      end
+    end
+    define_tests(PositiveTest)
+
+    class FalseTest
+      include Minispec
+
+      testing :false? do
+        is(false).false?
+      end
+      should ':fail' do
+        is(:blah).false?
+      end
+    end
+    define_tests(FalseTest)
+
+    class FalsyTest
+      include Minispec
+
+      testing :nil do
+        is(nil).falsy?
+      end
+      testing :false do
+        is(false).falsy?
+      end
+      should ':fail' do
+        is(:something).falsy?
+      end
+    end
+    define_tests(FalsyTest)
+
+    class ArrayTest
+      include Minispec
+
+      testing :same_elements do
+        a1 = [1, 2, :a, :b, :c]
+        a2 = [:b, 1, :c, 2, :a]
+        assert(a1).has.same_elements_as a2
+      end
+      should 'raise if non-Array given' do
+        does { assert('').has.same_elements '' }.raise? ArgumentError, /Array\?/
+      end
+      should 'raise if right array missing' do
+        does { assert([]).has.same_elements }.raise? ArgumentError
+      end
+      should ':fail if arrays size vary' do
+        assert([1]).has.same_elements [1,2]
+      end
+      should ':fail if arrays elements vary' do
+        assert([:a, :b]).has.same_elements [:x, :y]
+      end
+    end
+    define_tests(ArrayTest)
+
+    class ContainTest
+      include Minispec
+
+      should 'work with integers' do
+        does([1, 2, 5, 6]).contain? 1, 2
+      end
+      should 'work with floats' do
+        does([1.2, 2]).contain? 1.2
+      end
+      should 'work with strings' do
+        does([1.2, '2', 5, 4]).contain? '2', 4
+      end
+      should 'work with regexps' do
+        does([1.2, 'abc', 8, 9]).contain? /b/, 9
+      end
+      should ':fail if no element found' do
+        does([1, 2]).contain? :a
+      end
+      should ':fail if no element matched' do
+        does([:a, :b]).contain? /x/
+      end
+      should 'raise if non-Array given' do
+        does { assert(:blah).contain? :blah }.raise? ArgumentError
+      end
+    end
+    define_tests(ContainTest)
+
+    class ContainAnyTest
+      include Minispec
+
+      should 'work with integers' do
+        does([1, 2, 5, 6]).contain_any? 1, 8
+      end
+      should 'work with floats' do
+        does([4, 2]).contain_any? 2
+      end
+      should 'work with strings' do
+        does([1.2, '2', 5, 4]).contain_any? '2', 4
+      end
+      should 'work with regexps' do
+        does([1.2, 'abc', 8]).contain_any? /b/, 9
+      end
+      should ':fail if no element found' do
+        does([1, 2]).contain_any? :a
+      end
+      should ':fail if no element matched' do
+        does([:a, :b]).contain_any? /x/
+      end
+      should 'raise if non-Array given' do
+        does { assert(:blah).contain_any? :blah }.raise? ArgumentError
+      end
+    end
+    define_tests(ContainAnyTest)
+
+    class SilentTest
+      include Minispec
+
+      should 'pass' do
+        is { '' }.silent?
+      end
+
+      should ':fail because of stdout' do
+        assert { puts 'something' }.is_silent
+      end
+
+      should ':fail because of stderr' do
+        assert { warn 'something' }.is_silent
+      end
+
+      should 'pass when it is not silent and not expected to' do
+        assert { puts 'something' }.is_not.silent
+      end
+
+      should ':fail when it is silent but not expected to' do
+        assert {  }.is_not.silent
+      end
+    end
+    define_tests(SilentTest)
+
+    class LeftBlockTest
+      include Minispec
+
+      helper :blank? do |block|
+        is(&block).empty?
+      end
+
+      should 'pass' do
+        is { '' }.blank?
+      end
+
+      should ':fail' do
+        is { '-' }.blank?
+      end
+    end
+    define_tests(LeftBlockTest)
+
+    class RightBlockTest
+      include Minispec
+
+      helper :any_value? do |obj, block|
+        assert(obj).any?(&block)
+      end
+
+      should 'pass' do
+        has([1, 2]).any_value? {|v| v > 1}
+      end
+
+      should ':fail' do
+        has([1, 2]).any_value? {|v| v > 5}
+      end
+    end
+    define_tests(RightBlockTest)
+
+  end
+end

data/test/test__raise.rb

@@ -0,0 +1,104 @@
+class MinispecTest
+  class Raise < self
+
+    class Unit
+      include Minispec
+      continue_on_failures true
+
+      begin
+        should 'pass when error raised and expected' do
+          does { blah }.raise_error?
+        end
+
+        should ':fail when error expected but NOT raised' do
+          does { :blah }.raise_error?
+        end
+
+        should 'pass when NO error expected and NO error raised' do
+          refute { }.raise_error
+        end
+
+        should ':fail when error raised but NOT expected' do
+          refute { Blah }.raise_error
+        end
+        should ':fail when error raised but NOT expected - alternative syntax' do
+          assure { Blah }.does_not.raise_error
+        end
+      end
+
+      begin
+        should 'pass when raised error type match expected error type' do
+          expect { Blah }.to_raise_error NameError
+        end
+
+        should ':fail when raised error type match expected error type but negation used' do
+          refute { Blah }.raise NameError
+          assure { Blah }.does_not.raise NameError
+        end
+
+        should ':fail when raised error type DOES NOT match expected error type' do
+          does { Blah }.raise_error? StandardError
+        end
+      end
+
+      begin # error message as first argument
+        should 'pass when raised error message is equal to expected one' do
+          does { Blah }.raise_error? 'uninitialized constant MinispecTest::Raise::Unit::Blah'
+        end
+
+        should ':fail when raised error message is NOT equal to expected one' do
+          does { Blah }.raise_error? 'Blah'
+        end
+
+        should 'pass when raised error message match expected error message' do
+          does { Blah }.raise_error? /uninitialized constant/
+        end
+
+        should ':fail when raised error message match expected error message but negation used' do
+          refute { Blah }.raise_error    /uninitialized constant/
+          assure { Blah }.does_not.raise /uninitialized constant/
+        end
+
+        should ':fail when raised error message DOES NOT match expected error message' do
+          does { Blah }.raise_error? 'something that Ruby would never throw'
+        end
+      end
+
+      begin # error message as second argument
+        should 'pass when raised error matches expected one' do
+          does { Blah }.raise_error? NameError, /uninitialized constant/
+        end
+
+        should ':fail when raised error match expected error but negation used' do
+          refute { Blah }.raise_error? NameError,   /uninitialized constant/
+          assure { Blah }.does_not.raise NameError, /uninitialized constant/
+        end
+
+        should ':fail when type matching and message DOES NOT' do
+          does { Blah }.raise_error? NameError, 'something that Ruby would never throw'
+        end
+
+        should ':fail when message matching and type DOES NOT' do
+          does { Blah }.raise_error? ArgumentError, 'Blah'
+        end
+      end
+
+      begin # using a block to validate raised error
+        should 'pass when given block validates raised error' do
+          e_class = NameError
+          expect { Blah }.to_raise {|e| e.class == e_class }
+        end
+
+        should ':fail when given block does not validate raised error' do
+          expect { Blah }.to_raise {false}
+        end
+      end
+
+      should 'raise ArgumentError when both arguments and block given' do
+        does { expect { }.to_raise(NameError) {} }.raise? ArgumentError
+      end
+    end
+
+    define_tests(Unit)
+  end
+end