cutest 0.0.5 → 0.0.6

data/cutest.gemspec

@@ -1,11 +1,11 @@
 Gem::Specification.new do |s|
   s.name              = "cutest"
-  s.version           = "0.0.5"
+  s.version           = "0.0.6"
   s.summary           = "Forking tests."
   s.description       = "Run tests in separate processes to avoid shared state."
   s.authors           = ["Damian Janowski", "Michel Martens"]
   s.email             = ["djanowski@dimaion.com", "michel@soveran.com"]
   s.homepage          = "http://github.com/djanowski/cutest"
-  s.files = ["LICENSE", "README.markdown", "Rakefile", "lib/cutest.rb", "cutest.gemspec", "test/assert.rb", "test/assert_raise.rb", "test/prepare.rb", "test/setup.rb"]
+  s.files = ["LICENSE", "README.markdown", "Rakefile", "lib/cutest.rb", "cutest.gemspec", "test/assert.rb", "test/assert_raise.rb", "test/prepare.rb", "test/scopes.rb", "test/setup.rb"]
   s.add_dependency "batch", "~> 0.0.1"
 end

data/lib/cutest.rb

@@ -1,55 +1,7 @@
 require "batch"
 
-class AssertionFailed < StandardError; end
-
-def assert(value)
-  flunk unless value
-end
-
-def assert_raise(expected = Exception)
-  begin
-    yield
-  rescue => exception
-  ensure
-    flunk unless exception.kind_of?(expected)
-  end
-end
-
-def flunk(caller = caller[1])
-  ex = AssertionFailed.new(@_test)
-  ex.set_backtrace(caller)
-
-  file, line = ex.backtrace.shift.split(":")
-  code = File.readlines(file)[line.to_i - 1]
-
-  ex.message.replace(">> #{@_test}\n=> #{code.strip}\n   #{file} +#{line}")
-
-  raise ex
-end
-
-@_prepare = []
-
-def prepare(&block)
-  @_prepare << block if block_given?
-  @_prepare
-end
-
-@_setup = nil
-
-def setup(&block)
-  @_setup = block if block_given?
-  @_setup
-end
-
-def test(name = nil, &block)
-  @_test = name
-
-  prepare.each { |block| block.call }
-  block.call(setup && setup.call)
-end
-
 class Cutest < Batch
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 
   def report_errors
     return if @errors.empty?
@@ -83,8 +35,109 @@ class Cutest < Batch
       Process.wait
 
       output = read.read
-      raise AssertionFailed.new(output) unless output.empty?
+      raise Cutest::AssertionFailed.new(output) unless output.empty?
       read.close
     end
   end
+
+  class AssertionFailed < StandardError; end
+
+  class Scope
+    def initialize(&scope)
+      @scope = scope
+    end
+
+    def call
+      instance_eval(&@scope)
+    end
+  end
+end
+
+module Kernel
+private
+
+  # Use Thread.current[:cutest] to store information about test preparation and
+  # setup.
+  Thread.current[:cutest] ||= { :prepare => [] }
+
+  # Shortcut to access Thread.current[:cutest].
+  def cutest
+    Thread.current[:cutest]
+  end
+
+  # Create a class where the block will be evaluated. Recomended to improve
+  # isolation between tests.
+  def scope(&blk)
+    Cutest::Scope.new(&blk).call
+  end
+
+  # Prepare the environment in order to run the tests. This method can be called
+  # many times, and each new block is appened to a list of preparation blocks.
+  # When a test is executed, all the preparation blocks are ran in the order they
+  # were declared. If called without a block, it returns the array of preparation
+  # blocks.
+  def prepare(&block)
+    cutest[:prepare] << block if block_given?
+    cutest[:prepare]
+  end
+
+  # Setup parameters for the tests. The block passed to setup is evaluated before
+  # running each test, and the result of the setup block is passed to the test as
+  # a parameter. If the setup and the tests are declared at the same level (in
+  # the global scope or in a sub scope), it is possible to use instance
+  # variables, but the parameter passing pattern is recommended to ensure there
+  # are no side effects.
+  #
+  # If the setup blocks are declared in the global scope and the tests are
+  # declared in sub scopes, the parameter passing usage is required.
+  #
+  # Setup blocks can be defined many times, but each new definition overrides the
+  # previous one. It is recommended to split the tests in many different files
+  # (the report is per file, not per assertion). Usually one setup block per file
+  # is enough, but nothing forbids having different scopes with different setup
+  # blocks.
+  def setup(&block)
+    cutest[:setup] = block if block_given?
+    cutest[:setup]
+  end
+
+  # Call all the prepare blocks and setup blocks before executing the test. Even
+  # though the assertions can live anywhere (it's not mandatory to put them
+  # inside test blocks), it is necessary to wrap them in test blocks in order to
+  # execute preparation and setup blocks.
+  def test(name = nil, &block)
+    @_test = name
+
+    prepare.each { |block| block.call }
+    block.call(setup && setup.call)
+  end
+
+  # Assert that value is not nil or false.
+  def assert(value)
+    flunk unless value
+  end
+
+  # Assert that the block doesn't raise the expected exception.
+  def assert_raise(expected = Exception)
+    begin
+      yield
+    rescue => exception
+    ensure
+      flunk unless exception.kind_of?(expected)
+    end
+  end
+
+  # Stop the tests and raise an error where the message is the last line executed
+  # before flunking.
+  def flunk(caller = caller[1])
+    ex = Cutest::AssertionFailed.new(@_test)
+    ex.set_backtrace(caller)
+
+    file, line = ex.backtrace.shift.split(":")
+    code = File.readlines(file)[line.to_i - 1]
+
+    ex.message.replace(">> #{@_test}\n=> #{code.strip}\n   #{file} +#{line}")
+
+    raise ex
+  end
 end

data/test/assert.rb

@@ -3,7 +3,7 @@ test "succeeds if the value is true" do
 end
 
 test "raises if the assertion fails" do
-  assert_raise(AssertionFailed) do
+  assert_raise(Cutest::AssertionFailed) do
     assert false
   end
 end

data/test/assert_raise.rb

@@ -6,7 +6,7 @@ end
 
 
 test "raises if the expectation is not met" do
-  assert_raise(AssertionFailed) do
+  assert_raise(Cutest::AssertionFailed) do
     assert_raise(RuntimeError) do
       raise ArgumentError
     end

data/test/prepare.rb

@@ -1,19 +1,25 @@
 prepare do
-  @foo = []
+  $foo = []
 end
 
 prepare do
-  @foo << true
+  $foo << true
 end
 
 test "all the prepare blocks are called" do
-  assert @foo == [true]
+  assert $foo == [true]
 end
 
 prepare do
-  @foo << false
+  $foo << false
 end
 
 test "and are cumulative" do
-  assert @foo == [true, false]
+  assert $foo == [true, false]
+end
+
+module Foo
+  test "and run inside modules" do
+    assert $foo = [true, false]
+  end
 end

data/test/scopes.rb

@@ -0,0 +1,31 @@
+@bar = true
+
+prepare { $foo = false }
+
+scope do
+  @foo = true
+
+  test "something" do
+    assert !$foo
+    assert defined?(@foo)
+    assert !defined?(@bar)
+  end
+end
+
+scope do
+  test "something" do
+    assert !$foo
+    assert !defined?(@foo)
+    assert !defined?(@bar)
+  end
+end
+
+scope do
+  @baz = true
+
+  scope do
+    test "something" do
+      assert !defined?(@baz)
+    end
+  end
+end

data/test/setup.rb

@@ -21,3 +21,9 @@ end
 test "only the most recently defined setup block is executed" do |value|
   assert "Hello world!" == value
 end
+
+module Foo
+  test "works inside modules too" do |value|
+    assert "Hello world!" == value
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Damian Janowski
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-15 00:00:00 -03:00
+date: 2010-09-18 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,6 +52,7 @@ files:
 - test/assert.rb
 - test/assert_raise.rb
 - test/prepare.rb
+- test/scopes.rb
 - test/setup.rb
 has_rdoc: true
 homepage: http://github.com/djanowski/cutest