attest 0.1.0 → 0.2.0

data/lib/attest/output/failures_only_output_writer.rb

@@ -0,0 +1,47 @@
+require 'stringio'
+require 'attest/output/output_writer'
+require 'attest/expectation_result'
+
+module Attest
+  module Output
+    class FailuresOnlyOutputWriter < Attest::Output::OutputWriter
+      def initialize
+        super()
+        @relevant_outputs = StringIO.new
+      end
+
+      def after_all_tests
+        super
+        @relevant_outputs.rewind
+        2.times {puts}
+        puts @relevant_outputs.readlines
+      end
+
+      def before_container(container)
+        previous_container = @containers.last
+        @containers << container
+      end
+
+      def after_test(test_object)
+        relevant_result = determine_relevant_result test_object
+        if relevant_result && relevant_result.failure?
+          @relevant_outputs.puts "#{@containers.last.file}"
+          @relevant_outputs.puts " #{@containers.last.description}"
+          @relevant_outputs.puts "  - #{test_object.description} [#{relevant_result.status.upcase}]"
+          @relevant_outputs.puts "  #{relevant_result.source_location}"
+          @relevant_outputs.puts
+        elsif relevant_result && relevant_result.error?
+          e = relevant_result.attributes[:unexpected_error]
+          @relevant_outputs.puts "#{@containers.last.file}"
+          @relevant_outputs.puts " #{@containers.last.description}"
+          @relevant_outputs.puts "  - #{test_object.description} [#{relevant_result.status.upcase}]"
+          @relevant_outputs.puts "  #{e.class}: #{e.message}"
+          e.backtrace.each do |line|
+            @relevant_outputs.puts "   #{line} "
+          end
+          @relevant_outputs.puts
+        end
+      end
+    end
+  end
+end

data/lib/attest/output/output_writer.rb

@@ -0,0 +1,124 @@
+require 'attest/output/output_writer_interface'
+require 'attest/expectation_result'
+
+module Attest
+  module Output
+    class OutputWriter
+      include OutputWriterInterface
+      def initialize
+        self.instance_variable_set("@containers", [])
+        self.instance_variable_set("@start_time", nil)
+        self.instance_variable_set("@end_time", nil)
+      end
+
+      def before_all_tests
+        @start_time = Time.now
+      end
+      def after_all_tests
+        @end_time = Time.now
+      end
+      def before_container(container)
+      end
+      def after_container(container)
+      end
+      def before_test(test_object)
+      end
+      def after_test(test_object)
+      end
+      def summary
+        return unless @containers.size >= 1
+        expectation_status_hash = blank_status_hash
+        overall_test_status_hash = blank_status_hash
+        test_count = 0
+        @containers.each do |container|
+          container.test_objects.each do |test_object|
+            test_count += 1
+            current_test_statuses = determine_test_status test_object
+            overall_test_status_hash = merge_counting_hashes(overall_test_status_hash, current_test_statuses[0])
+            expectation_status_hash = merge_counting_hashes(expectation_status_hash, current_test_statuses[1])
+          end
+        end
+        puts
+        print "#{test_count} tests #{expectation_status_hash.inject(0){|sum, tuple| sum + tuple[1]}} expectations"
+        Attest::ExpectationResult.status_weights.sort{|a, b| a[1] <=> b[1]}.each {|status, weight| print " #{expectation_status_hash[status]} #{status.to_s}"}
+        puts
+        puts "Finished in #{elapsed_time(@end_time, @start_time)}"
+      end
+      def ignore_container(container)
+        if @containers.last.object_id == container.object_id
+          @containers.delete @containers.last 
+        else 
+          @containers.delete_if {|current_container| current_container.object_id == container.object_id}
+        end
+      end
+      def an_error(error_object)
+        puts "#{error_object.class}: #{error_object.message}"
+        error_object.backtrace.each do |line|
+          puts " #{line} "
+        end
+      end
+
+      private
+      def elapsed_time(end_time, start_time)
+        units = ["milliseconds", "seconds", "minutes", "hours"]
+        elapsed_seconds = end_time - start_time
+        if elapsed_seconds < 1
+          elapsed_time_as_string = "#{round_to(2, (elapsed_seconds * 1000))} #{units[0]}"
+        elsif elapsed_seconds >= 1 && elapsed_seconds < 60
+          elapsed_time_as_string = "#{round_to(2, elapsed_seconds)} #{units[1]}"
+        elsif elapsed_seconds >= 60 && elapsed_seconds < 3600
+          minsec = elapsed_seconds.divmod(60).collect{|num| round_to(2, num)}
+          elapsed_time_as_string = "#{minsec[0]} #{units[2]}, #{minsec[1]} #{units[1]}"
+        else
+          minsec = elapsed_seconds.divmod(60).collect{|num| round_to(2, num)}
+          hourminsec = minsec[0].divmod(60).collect{|num| round_to(2, num)}
+          hourminsec << minsec[1]
+          elapsed_time_as_string = "#{hourminsec[0]} #{units[3]}, #{hourminsec[1]} #{units[2]}, #{hourminsec[2]} #{units[1]}"
+        end
+        elapsed_time_as_string
+      end
+
+      def round_to(decimal_places, number)
+        rounded = (number * 10**decimal_places).round.to_f / 10**decimal_places 
+        rounded_as_int = (rounded == rounded.to_i ? rounded.to_i : rounded)
+        rounded_as_int
+      end
+
+      def determine_relevant_result(test_object)
+        relevant_result = nil
+        test_object.results.each do |result|
+          relevant_result = result unless result.success?
+        end
+        relevant_result
+      end
+
+      def determine_test_status(test_object)
+        expectation_status_hash = blank_status_hash
+        overall_test_status_hash = blank_status_hash
+        dominant_result = nil
+        test_object.results.each do |result|
+          expectation_status_hash[result.status.to_sym] += 1
+          dominant_result = result if result > dominant_result
+        end
+        raise "Unexpected result status encountered! WTF!!!" if expectation_status_hash.keys.size > Attest::ExpectationResult.status_types.size
+        raise "Test without status encountered, all test should have a status!" unless dominant_result 
+        overall_test_status_hash[dominant_result.status.to_sym] += 1
+        [overall_test_status_hash, expectation_status_hash]
+      end
+
+      def merge_counting_hashes(hash1, hash2)
+        hash1.inject(hash2) do |accumulator_hash, tuple|
+          accumulator_hash[tuple[0]] += tuple[1]
+          accumulator_hash
+        end
+      end
+
+      def blank_status_hash
+        Attest::ExpectationResult.status_types.inject({}) do |accumulator, status|
+          accumulator[status] = 0 
+          accumulator
+        end
+      end
+    end
+  end
+end

data/lib/attest/output/output_writer_interface.rb

@@ -0,0 +1,24 @@
+module Attest
+  module Output
+    module OutputWriterInterface
+      def before_all_tests
+      end
+      def after_all_tests
+      end
+      def before_container(container)
+      end
+      def after_container(container)
+      end
+      def before_test(test_object)
+      end
+      def after_test(test_object)
+      end
+      def summary
+      end
+      def ignore_container(container)
+      end
+      def an_error(error_object)
+      end
+    end
+  end
+end

data/lib/attest/output/test_unit_output_writer.rb

@@ -0,0 +1,32 @@
+require 'attest/output/output_writer'
+require 'attest/expectation_result'
+
+module Attest
+  module Output
+    class TestUnitOutputWriter < Attest::Output::OutputWriter
+      def before_all_tests
+        super
+        puts 
+      end
+
+      def after_all_tests
+        super
+        puts 
+      end
+
+      def before_container(container)
+        previous_container = @containers.last
+        @containers << container
+      end
+
+      def after_test(test_object)
+        relevant_result = determine_relevant_result test_object
+        if relevant_result
+          print "#{relevant_result.status.upcase[0]}"
+        else
+          print '.'
+        end
+      end
+    end
+  end
+end

data/lib/attest/proc/proc_source_reader.rb

@@ -0,0 +1,49 @@
+require 'stringio'
+require 'irb/ruby-lex'
+
+module Attest
+  class ProcSourceReader
+    def initialize(file, line)
+      @file = file
+      @start_line = line
+    end
+
+    def self.find(file, line)
+      source_reader = ProcSourceReader.new(file, line)
+      source_reader.read_source
+
+    end
+
+    def read_source
+      lines_starting_with_proc = read_lines_from_file
+      return nil if lines_starting_with_proc.nil?
+      lexer = RubyLex.new
+      lexer.set_input(StringIO.new(lines_starting_with_proc.join))
+      start_token, end_token = nil, nil
+      nesting = 0
+      while token = lexer.token
+        if RubyToken::TkDO === token || RubyToken::TkfLBRACE === token
+          nesting += 1
+          start_token = token if nesting == 1
+        elsif RubyToken::TkEND === token || RubyToken::TkRBRACE === token
+          if nesting == 1
+            end_token = token 
+            break
+          end
+          nesting -= 1
+        end
+      end
+      proc_lines = lines_starting_with_proc[start_token.line_no - 1 .. end_token.line_no - 1]
+      proc_lines
+    end
+
+    def read_lines_from_file
+      raise "No file for proc where does it come from" unless @file 
+      begin
+        File.readlines(@file)[(@start_line - 1) .. -1]
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/attest/rake/attesttask.rb

@@ -0,0 +1,38 @@
+require 'rake'
+require 'rake/tasklib'
+
+module Rake 
+  class AttestTask < TaskLib
+    attr_accessor :include, :exclude, :outputwriter, :testdouble
+    def initialize
+      @include = "attest/"
+      @exclude = nil
+      @outputwriter = "Basic"
+      @testdouble = "mocha"
+      yield self if block_given?
+      define
+    end
+
+    def define
+      desc "Run attest tests"
+      task :attest do
+        $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '../../../lib/'))) unless $:.include?(File.expand_path(File.join(File.dirname(__FILE__), '../../../lib')))
+        require 'attest'
+        require 'attest/interface/output_writer_configurator'
+        require 'attest/interface/test_double_configurator'
+        require 'attest/interface/possible_tests_configurator'
+
+        Attest.configure do |config|
+          config.output_writer = Attest::OutputWriterConfigurator.configure(@outputwriter)
+          config.testdouble = Attest::TestDoubleConfigurator.configure(@testdouble)
+          config.possible_tests = Attest::PossibleTestsConfigurator.configure(@include, @exclude)
+        end
+
+        require 'attest/test_loader'
+
+        Attest::TestLoader.execute(Attest.config.possible_tests, Attest.config.output_writer)
+      end
+      self
+    end
+  end
+end

data/lib/attest/test_container.rb

@@ -1,7 +1,10 @@
+require 'attest'
+
 module Attest
   class TestContainer
 
     attr_reader :description, :test_objects, :file
+    attr_accessor :before, :after
 
     def initialize(description)
       @file = Attest.current_file
@@ -14,11 +17,19 @@ module Attest
     end
 
     def execute_all
-      Attest.output_writer.before_context(self)
-      @test_objects.each do |test_object|
-        test_object.run
+      Attest.output_writer.before_container(self)
+      container_context = Attest::ExecutionContext.new
+      begin
+        container_context.instance_eval(&@before) if @before
+        @test_objects.each do |test_object|
+          test_object.run container_context
+        end
+        container_context.instance_eval(&@after) if @after
+      rescue => e
+        Attest.output_writer.an_error(e)
+        Attest.output_writer.ignore_container(self)
       end
-      Attest.output_writer.after_context
+      Attest.output_writer.after_container(self)
     end
   end
 end

data/lib/attest/test_loader.rb

@@ -0,0 +1,28 @@
+require 'attest'
+require 'attest/core_ext/kernel'
+
+module Attest
+  class TestLoader 
+    class << self
+      def execute(possible_tests, output_writer)
+        switch_on_attest_mode
+        output_writer.before_all_tests
+        possible_tests.each do |ruby_file|
+          Attest.config.current_file = ruby_file
+          load ruby_file 
+        end
+        output_writer.after_all_tests
+        output_writer.summary
+        switch_off_attest_mode
+      end
+
+      def switch_on_attest_mode
+        ENV["attest"] = "true"
+      end
+
+      def switch_off_attest_mode
+        ENV["attest"] = nil
+      end
+    end
+  end
+end

data/lib/attest/test_object.rb

@@ -1,58 +1,64 @@
+require 'attest'
+require 'attest/execution_context'
+require 'attest/expectation_result'
+
 module Attest
   class TestObject
     attr_reader :description, :results
-    attr_accessor :nosetup
+    attr_accessor :nosetup, :disabled, :before, :after
     def initialize(description, test_block)
       @description = description
       @test_block = test_block
-      @before = nil
-      @after = nil
-      @results = nil
-    end
-
-    def add_setup(block)
-      @before = block
+      @results = []
     end
 
-    def add_cleanup(block)
-      @after = block
-    end
-
-    def run
+    def run(persistent_context)
       Attest.output_writer.before_test(self)
       error = nil
-      context = Attest::ExecutionContext.new
+      context = Attest::ExecutionContext.new(persistent_context)
       begin
-       Object.class_eval do
-         define_method :itself do
-           subject = self
-           context.instance_eval {@subject = subject}
-           context
-         end
-       end
-       context.instance_eval(&@before) if @before && !nosetup
-       context.instance_eval(&@test_block) if @test_block
-       context.instance_eval(&@after) if @after && !nosetup
+       #Object.class_eval do
+         #define_method :itself do
+           #subject = self
+           #context.instance_eval {@subject = subject}
+           #context
+         #end
+       #end
+       context.instance_eval(&@before) if @before && !nosetup && !disabled
+       context.instance_eval(&@test_block) if @test_block && !disabled
+       context.instance_eval(&@after) if @after && !nosetup && !disabled
       rescue => e
         error = e
       ensure
         @results = context.results
         add_unexpected_error_result(error) if error
         add_pending_result unless @test_block
+        add_disabled_result if disabled
+        add_success_result if @results.size == 0
       end
       Attest.output_writer.after_test(self)
     end
 
     private
     def add_unexpected_error_result(error)
-      result = Attest::ExpectationResult.new(:unexpected_error => error)
-      result.error
-      @results << result
+      create_and_add_result(:unexpected_error => error) {|result| result.error}
     end
 
     def add_pending_result
-      result = Attest::ExpectationResult.new
-      result.pending
+      create_and_add_result{|result| result.pending}
+    end
+
+    def add_disabled_result
+      create_and_add_result{|result| result.disabled}
+    end
+
+    def add_success_result
+      create_and_add_result{|result| result.success}
+    end
+
+    def create_and_add_result(opts={})
+      result = Attest::ExpectationResult.new(opts)
+      yield result
       @results << result
     end
   end