assert 0.1.0

data/lib/assert/context.rb

@@ -0,0 +1,196 @@
+require 'assert/suite'
+require 'assert/assertions'
+require 'assert/result'
+
+module Assert
+  class Context
+    include Assert::Assertions
+
+    # a Context is a scope for tests to run in.  Contexts have setup and
+    # teardown blocks, subjects, and descriptions.  Tests are run in the
+    # scope of a Context instance.  Therefore, a Context should have
+    # minimal base logic/methods/instance_vars.  The instance should remain
+    # pure to not pollute test scopes.
+
+    # if a class subclasses Context, add it to the suite
+    def self.inherited(klass)
+      Assert.suite << klass
+    end
+
+    # put all logic here to keep context instances pure for running tests
+    class << self
+      attr_accessor :subject_block
+
+      def setup_once(&block)
+        Assert.suite.setup(&block)
+      end
+      alias_method :before_once, :setup_once
+
+      def teardown_once(&block)
+        Assert.suite.teardown(&block)
+      end
+      alias_method :after_once, :teardown_once
+
+      def setup(&block)
+        raise ArgumentError, "please provide a setup block" unless block_given?
+        self.setup_blocks << block
+      end
+      alias_method :before, :setup
+
+      def teardown(&block)
+        raise ArgumentError, "please provide a teardown block" unless block_given?
+        self.teardown_blocks << block
+      end
+      alias_method :after, :teardown
+
+      def setup_blocks
+        @setup_blocks ||= []
+      end
+
+      def teardown_blocks
+        @teardown_blocks ||= []
+      end
+
+      def all_setup_blocks
+        inherited_blocks = if superclass.respond_to?(:all_setup_blocks)
+          superclass.all_setup_blocks
+        end
+        (inherited_blocks || []) + self.setup_blocks
+      end
+
+      def all_teardown_blocks
+        inherited_blocks = if superclass.respond_to?(:all_teardown_blocks)
+          superclass.all_teardown_blocks
+        end
+        (inherited_blocks || []) + self.teardown_blocks
+      end
+
+      def desc(text)
+        raise ArgumentError, "no context description provided" if text.nil?
+        self.descriptions << text
+      end
+      alias_method :description, :desc
+
+      def descriptions
+        @descriptions ||= []
+      end
+
+      def full_description
+        inherited_description = if superclass.respond_to?(:full_description)
+          superclass.full_description
+        end
+        parts = [ inherited_description ].push(self.descriptions).flatten.reject do |part|
+         !part || part.to_s.empty?
+        end
+        parts.join(" ") if !parts.empty?
+      end
+
+      def subject(&block)
+        raise ArgumentError, "please provide a subject block" unless block_given?
+        self.subject_block = block
+      end
+
+      def subject_block
+        @subject_block ||= if superclass.respond_to?(:subject_block)
+          superclass.subject_block
+        end
+      end
+
+      def should(desc, &block)
+        raise ArgumentError, "please provide a test block" unless block_given?
+        method_name = "test: should #{desc}"
+        if method_defined?(method_name)
+          from = caller.first
+          puts "WARNING: should #{desc.inspect} is redefining #{method_name}!"
+          puts "  from: #{from}"
+        end
+        define_method(method_name, &block)
+      end
+      
+      def should_eventually(desc, &block)
+        should(desc){ skip }
+      end
+
+    end
+
+    def initialize(running_test = nil)
+      @__running_test__ = running_test
+    end
+
+    # check if the assertion is a truthy value, if so create a new pass result, otherwise
+    # create a new fail result with the desc and what failed msg.
+    # all other assertion helpers use this one in the end
+    def assert(assertion, fail_desc=nil, what_failed_msg=nil)
+      what_failed_msg ||= "Failed assert: assertion was <#{assertion.inspect}>."
+      msg = fail_message(fail_desc) { what_failed_msg }
+      assertion ? pass : fail(msg)
+    end
+
+    # the opposite of assert, check if the assertion is a false value, if so create a new pass
+    # result, otherwise create a new fail result with the desc and it's what failed msg
+    def assert_not(assertion, fail_desc=nil)
+      what_failed_msg = "Failed assert_not: assertion was <#{assertion.inspect}>."
+      assert(!assertion, fail_desc, what_failed_msg)
+    end
+    alias_method :refute, :assert_not
+
+    # adds a Skip result to the end of the test's results and breaks test execution
+    def skip(skip_msg=nil)
+      raise(Result::TestSkipped, skip_msg || "")
+    end
+
+    # adds a Pass result to the end of the test's results
+    # does not break test execution
+    def pass(pass_msg=nil)
+      capture_result do |test_name, backtrace|
+        Assert::Result::Pass.new(test_name, pass_msg, backtrace)
+      end
+    end
+
+    # adds a Fail result to the end of the test's results
+    # does not break test execution
+    def fail(fail_msg=nil)
+      capture_result do |test_name, backtrace|
+        message = (fail_message(fail_msg) { }).call
+        Assert::Result::Fail.new(test_name, message, backtrace)
+      end
+    end
+    alias_method :flunk, :fail
+
+    # adds an Ignore result to the end of the test's results
+    # does not break test execution
+    def ignore(ignore_msg=nil)
+      capture_result do |test_name, backtrace|
+        Assert::Result::Ignore.new(test_name, ignore_msg, backtrace)
+      end
+    end
+
+    def subject
+      if subject_block = self.class.subject_block
+        instance_eval(&subject_block)
+      end
+    end
+
+    def inspect
+      "#<#{self.class}>"
+    end
+
+    protected
+
+    def capture_result
+      if block_given?
+        result = yield @__running_test__.name, caller
+        @__running_test__.results << result
+        result
+      end
+    end
+
+    # Returns a Proc that will output a custom message along with the default fail message.
+    def fail_message(fail_desc=nil, &what_failed)
+      fail_desc.kind_of?(::Proc) ? fail_desc : Proc.new do
+        [ what_failed.call, fail_desc ].compact.join("\n")
+      end
+    end
+
+  end
+end

data/lib/assert/options.rb

@@ -0,0 +1,43 @@
+module Assert
+  module Options
+
+    class Base
+      def method_missing(method, *args, &block)
+        if args.empty?
+          self.instance_variable_get("@#{method}")
+        else
+          value = args.size == 1 ? args.first : args
+          self.instance_variable_set("@#{method}", value)
+          if method.to_s =~ /^default_/
+            self.instance_variable_set("@#{$'}", value)
+          end
+        end
+      end
+
+    end
+
+    def self.included(receiver)
+      receiver.send(:class_variable_set, "@@options", Base.new)
+      receiver.send(:extend, ClassMethods)
+      receiver.send(:include, InstanceMethods)
+    end
+
+    module ClassMethods
+      def options(&block)
+        options = self.send(:class_variable_get, "@@options")
+        if block_given?
+          options.instance_eval(&block)
+        else
+          options
+        end
+      end
+    end
+
+    module InstanceMethods
+      def options
+        self.class.options
+      end
+    end
+
+  end
+end

data/lib/assert/rake_tasks.rb

@@ -0,0 +1,95 @@
+require 'rake'
+require 'rake/tasklib'
+
+module Assert; end
+module Assert::RakeTasks
+
+  FILE_SUFFIX = "_test.rb"
+
+  class TestTask < Rake::TaskLib
+    attr_accessor :name, :description, :test_files
+
+    # Create a testing task.
+    def initialize(name=:test)
+      @name = name
+      @description = "Run tests" + (@name==:test ? "" : " for #{@name}")
+      @test_files = []
+      yield self if block_given?
+    end
+
+    # Define the rake task to run this test suite
+    def to_task
+      desc @description
+      task @name do
+        RakeFileUtils.verbose(true) { ruby "\"#{rake_loader}\" " + file_list }
+      end
+    end
+
+    def file_list # :nodoc:
+      @test_files.collect{|f| "\"#{f}\""}.join(' ')
+    end
+
+    protected
+
+    def rake_loader # :nodoc:
+      find_file('rake/rake_test_loader') or
+        fail "unable to find rake test loader"
+    end
+
+    def find_file(fn) # :nodoc:
+      $LOAD_PATH.each do |path|
+        file_path = File.join(path, "#{fn}.rb")
+        return file_path if File.exist? file_path
+      end
+      nil
+    end
+  end
+
+  class << self
+    def for(test_namespace = :test)
+      self.irb_task(test_namespace.to_s)
+      self.to_tasks(test_namespace.to_s)
+    end
+
+    def irb_task(path)
+      irb_file = File.join(path, "irb.rb")
+      if File.exist?(irb_file)
+        desc "Open irb preloaded with #{irb_file}"
+        task :irb do
+          sh "irb -rubygems -r ./#{irb_file}"
+        end
+      end
+    end
+
+    def to_tasks(path)
+      suite_name = File.basename(path)
+
+      # define a rake test task for all top-level test files at this path
+      if !Dir.glob(File.join(path, "**/*#{FILE_SUFFIX}")).empty?
+        TestTask.new(suite_name.to_sym) do |t|
+          file_location = suite_name == path ? '' : " for #{File.join(path.split(File::SEPARATOR)[1..-1])}"
+          t.description = "Run all tests#{file_location}"
+          t.test_files = FileList["#{path}/**/*#{FILE_SUFFIX}"]
+        end.to_task
+      end
+
+      namespace suite_name.to_s do
+        # define rake test tasks for each top-level test file individually
+        Dir.glob(File.join(path, "*#{FILE_SUFFIX}")).each do |test_file|
+          test_name = File.basename(test_file, FILE_SUFFIX)
+          TestTask.new(test_name.to_sym) do |t|
+            t.description = "Run tests for #{[path.split(File::SEPARATOR), test_name].flatten[1..-1].join(':')}"
+            t.test_files = FileList[test_file]
+          end.to_task
+        end
+
+        # recursively define rake test tasks for each file
+        # in each top-level directory
+        Dir.glob(File.join(path, "*/")).each do |test_dir|
+          self.to_tasks(test_dir)
+        end
+      end
+    end
+  end
+
+end

data/lib/assert/result.rb

@@ -0,0 +1,164 @@
+module Assert; end
+module Assert::Result
+
+  class Base; end
+  class Pass < Base; end
+  class Fail < Base; end
+  class Ignore < Base; end
+  class FromException < Base; end
+  class Error < FromException; end
+  class Skip < FromException; end
+
+  class << self
+    def types
+      { :pass => Pass,
+        :fail => Fail,
+        :ignore => Ignore,
+        :skip => Skip,
+        :error => Error
+      }
+    end
+  end
+
+  class Backtrace < ::Array
+    # ripped from minitest...
+
+    file = File.expand_path __FILE__
+           # if RUBY_VERSION =~ /^1\.9/ then  # bt's expanded, but __FILE__ isn't :(
+           #    File.expand_path __FILE__
+           # elsif  __FILE__ =~ /^[^\.]/ then # assume both relative
+           #   require 'pathname'
+           #   pwd = Pathname.new Dir.pwd
+           #   pn = Pathname.new File.expand_path(__FILE__)
+           #   relpath = pn.relative_path_from(pwd) rescue pn
+           #   pn = File.join ".", relpath unless pn.relative?
+           #   pn.to_s
+           # else                             # assume both are expanded
+           #   __FILE__
+           # end
+
+    # './lib' in project dir, or '/usr/local/blahblah' if installed
+    ASSERT_DIR = File.dirname(File.dirname(file))
+
+    def initialize(value=nil)
+      super(value || ["No backtrace"])
+    end
+
+    def to_s
+      self.join("\n")
+    end
+
+    def filtered
+      new_bt = []
+
+      self.each do |line|
+        break if line.rindex ASSERT_DIR, 0
+        new_bt << line
+      end
+
+      new_bt = self.reject { |line| line.rindex ASSERT_DIR, 0 } if new_bt.empty?
+      new_bt = self.dup if new_bt.empty?
+
+      self.class.new(new_bt)
+    end
+  end
+
+
+  # Result classes...
+
+  class Base
+
+    attr_reader :test_name, :message, :backtrace
+
+    def initialize(test_name, message, backtrace=nil)
+      @backtrace = Backtrace.new(backtrace)
+      @test_name = test_name
+      @message = message && !message.empty? ? message : nil
+    end
+
+    Assert::Result.types.keys.each do |meth|
+      define_method("#{meth}?") { false }
+    end
+
+    def to_sym; nil; end
+
+    def to_s
+      [self.test_name, self.message, self.trace].compact.join("\n")
+    end
+
+    def trace
+      self.backtrace.filtered.first.to_s
+    end
+    
+    def ==(other)
+      self.class == other.class && self.message == other.message
+    end
+    
+    def inspect
+      "#<#{self.class} @message=#{self.message.inspect}>"
+    end
+
+  end
+
+  class Pass < Base
+    def pass?; true; end
+    def to_sym; :passed; end
+
+    def to_s
+      "PASS: #{super}"
+    end
+  end
+
+  class Fail < Base
+    def fail?; true; end
+    def to_sym; :failed; end
+
+    def to_s
+      "FAIL: #{super}"
+    end
+  end
+
+  class Ignore < Base
+    def ignore?; true; end
+    def to_sym; :ignored; end
+
+    def to_s
+      "IGNORE: #{super}"
+    end
+  end
+
+  # Error and Skip results are built from exceptions being raised
+  class FromException < Base
+    def initialize(test_name, exception)
+      super(test_name, exception.message, exception.backtrace || [])
+    end
+  end
+
+  # raised by the 'skip' context helper to break test execution
+  class TestSkipped < RuntimeError; end
+
+  class Skip < FromException
+    def skip?; true; end
+    def to_sym; :skipped; end
+
+    def to_s
+      "SKIP: #{super}"
+    end
+  end
+
+  class Error < FromException
+
+    def error?; true; end
+    def to_sym; :errored; end
+
+    def to_s
+      "ERROR: #{super}"
+    end
+
+    # override of the base, always show the full unfiltered backtrace for errors
+    def trace
+      self.backtrace.to_s
+    end
+  end
+
+end