attest 0.1.0 → 0.2.0

data/lib/attest/execution_context.rb

@@ -1,84 +1,190 @@
+require 'attest/expectation_result'
+
 module Attest
   class ExecutionContext
     attr_reader :results
 
-    def initialize
-      @results = []
-      @subject = self
+    class << self
+      def assertions
+        self.instance_methods(false).select{|method_name| method_name =~ /^should.*/ }.inspect
+      end
     end
 
-    def should_raise(type=nil, &block)
-      result = Attest::ExpectationResult.new
-      begin
-        if block_given?
-          yield
-        end
-      rescue => e
-        result.update(:expected_error => e)
-        if type && type == e.class
-          result.success
-        else
-          result.success
+    def initialize(context=nil)
+      @results = []
+      @subject = self
+      @persistent_context = context
+      own_instance_variables = self.instance_variables
+      context.instance_variables.each do |instance_variable|
+        unless own_instance_variables.include? instance_variable
+          self.instance_variable_set(instance_variable.to_s, context.instance_variable_get(instance_variable))
         end
       end
-      unless result.success?
-        result.failure 
+    end
+
+    def should_be(expected_lambda, &block)
+      with_new_result do |result|
+        expected_lambda.call == yield ? result.success : result.failure
       end
-      @results << result
-      self
     end
+    alias :should_be_a :should_be
+    alias :should_be_an :should_be
+    alias :should_match :should_be
+    alias :should_match_a :should_be
+    alias :should_match_an :should_be
 
-    def with_message(regex)
-      result = @results.last
-      if result.success? && result.attributes[:expected_error]
-        if !(result.attributes[:expected_error].message =~ regex)
-          result.failure
-        end
+    def should_not_be(expected_lambda, &block)
+      with_new_result do |result|
+        expected_lambda.call != yield ? result.success : result.failure
       end
-      self
     end
+    alias :should_not_be_a :should_not_be
+    alias :should_not_be_an :should_not_be
+    alias :should_not_match :should_not_be
+    alias :should_not_match_a :should_not_be
+    alias :should_not_match_an :should_not_be
+
+    def should_be_same(expected_value, actual_value=nil, &block)
+      derive_result_status_from_method(expected_value, actual_value, :"equal?", &block)
+    end
+    alias :should_be_same_as :should_be_same
+
+    def should_not_be_same(expected_value, actual_value=nil, &block)
+      derive_result_status_from_method_negated(expected_value, actual_value, :"equal?", &block)
+    end
+    alias :should_not_be_same_as :should_not_be_same
+
+    def should_equal(expected_value, actual_value=nil, &block)
+      derive_result_status_from_method(expected_value, actual_value, :"==", &block)
+    end
+
+    def should_not_equal(expected_value, actual_value=nil, &block)
+      derive_result_status_from_method_negated(expected_value, actual_value, :"==", &block)
+    end
+    alias :should_not_be_equal :should_not_equal
+
+    def should_be_true(actual_value=nil, &block)
+      derive_result_status_from_method(true, actual_value, :"==", &block)
+    end
+
+    def should_not_be_true(actual_value = nil, &block)
+      derive_result_status_from_method(false, actual_value, :"==", &block)
+    end
+    alias :should_be_false :should_not_be_true
 
     def should_fail
-      result = Attest::ExpectationResult.new
-      result.failure
-      @results << result
-      self
+      with_new_result do |result|
+        result.failure
+      end
     end
+    alias :should_not_succeed :should_fail
 
-    def should_be_true(&block)
-      result = Attest::ExpectationResult.new
-      block_return = yield
-      block_return ? result.success : result.failure
-      @results << result
-      self
+    def should_succeed
+      with_new_result do |result|
+        result.success
+      end
     end
+    alias :should_not_fail :should_succeed
+    alias :should_pass :should_succeed
 
     def should_not_raise(&block)
       should_raise(&block)
-      result = @results.last
-      result.success? ? result.failure : result.success
-      self
+      with_last_result do |result|
+        result.success? ? result.failure : result.success
+      end
     end
 
-    def should_not_be_true(&block)
-      should_be_true(&block)
-      result = @results.last
-      result.success? ? result.failure : result.success
-      self
+    #the only opt so far is :with_message which takes a regex
+    def should_raise(type=nil, opts={}, &block)
+      with_new_result do |result|
+        begin
+          if block_given?
+            yield
+          end
+        rescue => e
+          result.update(:expected_error => e)
+          if expected_error?(type, opts[:with_message], e)
+            result.success
+          else
+            result.failure
+          end
+        end
+        unless result.success?
+          result.failure 
+        end
+      end
     end
 
     #worker methods
     def create_and_include(module_class)
       class_name = "#{module_class}Class"
-      class_instance = Class.new
-      Object.const_set class_name, class_instance
-      Object.const_get(class_name).include(Object.const_get("#{module_class}"))
-      klass = Object.const_get(class_name)
+      klass = nil
+      begin
+        klass = Object.const_get(class_name)
+      rescue NameError => e
+        class_instance = Class.new
+        Object.const_set class_name, class_instance
+        Object.const_get(class_name).include(Object.const_get("#{module_class}"))
+        klass = Object.const_get(class_name)
+      end
       klass.new
     end
 
-    def nosetup
-      true
+    private 
+    def derive_result_status_from_method(expected_value, actual_value, method, negated=false, &block)
+      with_new_result do |result|
+        if block_given?
+          method_return = expected_value.send(method, yield)
+          method_return = !method_return if negated
+          method_return ? result.success : result.failure
+        else
+          method_return = expected_value.send(method, actual_value)
+          method_return = !method_return if negated
+          method_return ? result.success : result.failure
+        end
+      end
+    end
+
+    def derive_result_status_from_method_negated(expected_value, actual_value, method, &block)
+      derive_result_status_from_method(expected_value, actual_value, method, true, &block)
+    end
+
+    def source_location
+      caller.each_with_index do |stack_line|
+        if stack_line[Attest.config.current_file]
+          return stack_line[/(.*:\d+):.*/, 1]
+        end
+      end
+      ""
+    end
+
+    def with_new_result
+      result = Attest::ExpectationResult.new
+      yield result
+      result.source_location = source_location
+      @results << result
+    end
+
+    def with_last_result
+      result = @results.last
+      yield result
+      result.source_location = source_location
+    end
+
+    def expected_error?(expected_type, expected_message_regex, actual_error)
+      if expected_type.nil? && expected_message_regex.nil? || expected_error_type?(expected_type, actual_error.class) && expected_message_regex.nil? || expected_error_type?(expected_type, actual_error.class) && error_message_matches?(expected_message_regex, actual_error.message)
+        return true
+      else
+        return false
+      end
+    end
+
+    def expected_error_type?(expected_type, actual_type)
+      expected_type == actual_type
+    end
+
+    def error_message_matches?(expected_message_regex, actual_error_message)
+      actual_error_message =~ expected_message_regex
     end
   end
 end

data/lib/attest/expectation_result.rb

@@ -1,12 +1,24 @@
 module Attest
   class ExpectationResult
+    include Comparable
+    class << self
+      def status_types
+        status_weights.keys
+      end
+
+      def status_weights
+        {:success => 1, :failure => 2, :error => 3, :pending => 4, :disabled => 5}
+      end
+    end
+
     attr_reader :attributes
+    attr_accessor :source_location
     def initialize(attributes={})
       @outcome = nil
       @attributes = attributes
     end
 
-    [:success, :failure, :error, :pending].each do |status|
+    Attest::ExpectationResult.status_types.each do |status|
       eval <<-EOT
         def #{status}
           @outcome = current_method
@@ -24,5 +36,14 @@ module Attest
     def update(attributes={})
       @attributes.merge!(attributes)
     end
+
+    def status_weight
+      Attest::ExpectationResult.status_weights[status.to_sym]
+    end
+
+    def <=>(another_result)
+      return 1 unless another_result
+      self.status_weight <=> another_result.status_weight
+    end
   end
 end

data/lib/attest/interface/output_writer_configurator.rb

@@ -0,0 +1,25 @@
+require 'attest/output/basic_output_writer'
+require 'attest/output/test_unit_output_writer'
+require 'attest/output/failures_only_output_writer'
+
+module Attest
+  class OutputWriterConfigurator
+    class << self
+      def configure(output_writer_identifier)
+        output_writer_identifier = output_writer_identifier || default_output_writer_identifier
+        raise "You have specified an unknown output writer" unless output_writer_identifiers.include? output_writer_identifier
+        output_writer_class = "#{output_writer_identifier}OutputWriter"
+        #Attest.config.output_writer = Attest::Output.const_get(output_writer_class).new
+        Attest::Output.const_get(output_writer_class).new
+      end
+
+      def default_output_writer_identifier
+        "Basic"
+      end
+
+      def output_writer_identifiers
+        [default_output_writer_identifier, "TestUnit", "FailuresOnly"]
+      end
+    end
+  end
+end

data/lib/attest/interface/possible_tests_configurator.rb

@@ -0,0 +1,35 @@
+module Attest
+  class PossibleTestsConfigurator
+    class << self
+      def configure(included_locations, excluded_locations = nil)
+        raise "Need to know location for tests" if included_locations.compact.size == 0
+        possible_test_files = included_test_files included_locations
+        files_to_ignore = excluded_test_files excluded_locations
+        possible_test_files - files_to_ignore
+      end
+
+      def included_test_files(included_locations)
+        file_list_from_list_of included_locations
+      end
+
+      def excluded_test_files(excluded_locations)
+        return [] if excluded_locations.nil?
+        file_list_from_list_of excluded_locations
+      end
+
+      def file_list_from_list_of(locations)
+        file_list = []
+        locations.compact.each do |location|
+          expanded_location = File.expand_path(location)
+          file_list << file_list_from_single(expanded_location)
+        end
+        file_list.flatten
+      end
+
+      def file_list_from_single(location)
+        return location if File.file? location
+        Dir[File.join(File.expand_path(location), "**/*.rb")].collect { |ruby_file| ruby_file }
+      end
+    end
+  end
+end

data/lib/attest/interface/test_double_configurator.rb

@@ -0,0 +1,40 @@
+require 'attest/execution_context'
+
+module Attest
+  class TestDoubleConfigurator 
+    class << self
+      def configure(test_double_identifier)
+        test_double_identifier = test_double_identifier || default_test_double_identifier 
+        raise "You have specified an unsupported test double framework" unless test_double_identifiers.include? test_double_identifier
+        self.send(:"configure_#{test_double_identifier}")
+        #Attest.config.testdouble = test_double_identifier
+        test_double_identifier
+      end
+
+      def configure_mocha
+        begin
+          #how would this work when bundler is in play
+          require "mocha_standalone"
+        rescue LoadError => e
+          puts "Trying to use mocha for test double functionality, but can't find it!"
+          puts "Perhaps you forgot to install the mocha gem."
+          exit
+        end
+        Attest::ExecutionContext.class_eval do
+          include Mocha::API # need this so that methods like stub() and mock() can be accessed directly from the execution context
+        end
+      end
+
+      def configure_none
+      end
+
+      def default_test_double_identifier
+        "mocha"
+      end
+
+      def test_double_identifiers
+        [default_test_double_identifier, "none"]
+      end
+    end
+  end
+end

data/lib/attest/output/basic_output_writer.rb

@@ -1,31 +1,31 @@
+require 'attest/output/output_writer'
+require 'attest/expectation_result'
+
 module Attest
   module Output
-    class BasicOutputWriter
-      def initialize
-        @containers = []
-      end
-
-      def before_everything
-      end
-
-      def before_context(container)
+    class BasicOutputWriter < Attest::Output::OutputWriter
+      def before_container(container)
         previous_container = @containers.last
         @containers << container
         puts "#{container.file}:" unless previous_container && previous_container.file == container.file
         puts " #{ container.description }"
       end
 
+      def after_container(container)
+        puts 
+      end
+
       def before_test(test_object)
         print "  - #{test_object.description}"
       end
 
       def after_test(test_object)
-        relevant_result = nil
-        test_object.results.each do |result|
-          relevant_result = result if !result.success?
-        end
+        relevant_result = determine_relevant_result test_object
         print " [#{relevant_result.status.upcase}]" if relevant_result
-        if relevant_result && relevant_result.error?
+        if relevant_result && relevant_result.failure?
+          2.times { puts } 
+          puts "     #{relevant_result.source_location}"
+        elsif relevant_result && relevant_result.error?
           e = relevant_result.attributes[:unexpected_error]
           2.times { puts } 
           puts "     #{e.class}: #{e.message}"
@@ -36,38 +36,6 @@ module Attest
         end
         puts
       end
-
-      def after_context
-        puts 
-      end
-
-      def summary
-        return unless @containers.size >= 1
-        tests, success, failure, error, pending = 0, 0, 0, 0, 0
-        @containers.each do |container|
-          container.test_objects.each do |test_object|
-            tests += 1
-            test_object.results.each do |result|
-              if result.success?
-                success += 1
-              elsif result.failure?
-                failure += 1
-              elsif result.error?
-                error += 1
-              elsif result.pending?
-                pending += 1
-              else
-                raise "Errr, WTF!!!"
-              end
-            end
-          end
-        end
-        puts
-        puts "Ran #{tests} tests: #{success} successful, #{failure} failed, #{error} errors, #{pending} pending"
-      end
-
-      def after_everything
-      end
     end
   end
 end