tunit 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5769b36f6ff1b870f97abe003b76ec180c387e17
+  data.tar.gz: 6c35816f53a6e5e5b3e1f310482338e7f263ff79
+SHA512:
+  metadata.gz: 9aeb067328c6d07e694215c0b77794a78645e4e49f71a806e9d13a0713be5b300f0585472fa893d410a6133862ba5724da8bac2f1116358bd9fff171567d37d1
+  data.tar.gz: 7b6754bb52f757ccfe7d1a2bb344f7fee592d2a29da47dbe896a8113b6e21a028380c050ea4fb7da851914946c6367111fcaa45abd83e964d5b11f14c93a73c4

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tunit.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Teo Ljungberg
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,113 @@
+# Tunit
+
+`tunit` is my take on building a testing framework, it's heavily influenced by
+[minitest](https://github.com/seattlerb/minitest).
+
+
+_NOTE_ This is very unstable and is just a playground for my ideas.
+
+## Credit
+Since this is heavily influenced by
+[Ryan Davis](https://twitter.com/the_zenspider)' minitest there are a lot of
+similarities between the two frameworks.
+
+I wanted to see how much code and effort are needed to build a testing
+framework of my own, while looking at the learnings of minitest.
+
+## Usage
+### Unit
+
+I personally _love_ TDD frameworks like minitest, so I tried to mimic their
+behaviour and patterns as close as I possibly could. As with minitest, this is
+just plain ruby.
+
+```ruby
+class BlahTest < Tunit::Test
+  def setup
+    self.blah = Blah.new
+  end
+  attr_accessor :blah
+
+  def test_the_answer_to_everything
+    assert_equal 42, blah.the_ultimate_answer
+  end
+
+  def test_packing_list
+    assert_includes blah.packing_list, "towel"
+  end
+
+  def test_that_will_be_skipped
+    skip "test this later"
+  end
+end
+```
+
+What's important to me is that `BlahTest` is just a simple subclass, and
+`test_the_answer_to_everything` is a simple method. Assertions and
+lazily-loaded variables are just methods, everything is just a simple method
+definition away.
+
+I'm a strong believer in that you should only mock and stub things so you can
+assert on something else. That's why a `test`-method must have assertions in
+`tunit`
+
+```ruby
+class EmptyTest < Tunit::Test
+  def test_im_going_to_fail
+  end
+
+  def test_so_will_i
+    1 + 1 == 2
+  end
+end
+```
+
+### Spec
+There is also a small Spec DSL that follows along with tunit
+
+```ruby
+require 'tunit/autorun'
+
+Example = Class.new
+
+describe Example do
+  describe 'passing tests' do
+    it 'even' do
+      assert 2.even?
+    end
+
+    it 'passed once more' do
+      assert_includes [1, 2], 2
+    end
+  end
+
+  describe 'failing tests' do
+    it 'fails on empty tests' do
+    end
+
+    it 'fails hard' do
+      refute 2.even?
+    end
+  end
+
+  describe 'skipps' do
+    it 'skippedy skip' do
+      skip
+    end
+
+    it 'skips with a message' do
+      skip 'here!'
+    end
+  end
+end
+```
+
+That's it, no magic let's or subjects. Just `it` and `describe` blocks
+
+## Contributing
+
+1. Fork it ( http://github.com/teoljungberg/tunit/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  ENV["RUBYOPT"] = "-w"
+  t.pattern      = "test/**/*_test.rb"
+  t.libs         << "test"
+end
+task :default => :test

data/example_spec.rb

@@ -0,0 +1,35 @@
+$:<< File.join(File.dirname(__FILE__), 'lib')
+require 'tunit/autorun'
+
+Example = Class.new
+
+describe Example do
+  describe 'passing tests' do
+    it 'even' do
+      assert 2.even?
+    end
+
+    it 'passed once more' do
+      assert_includes [1, 2], 2
+    end
+  end
+
+  describe 'failing tests' do
+    it 'fails on empty tests' do
+    end
+
+    it 'fails hard' do
+      refute 2.even?
+    end
+  end
+
+  describe 'skipps' do
+    it 'skippedy skip' do
+      skip
+    end
+
+    it 'skips with a message' do
+      skip 'here!'
+    end
+  end
+end

data/example_test.rb

@@ -0,0 +1,23 @@
+$:<< File.join(File.dirname(__FILE__), 'lib')
+require 'tunit/autorun'
+
+class ExampleTest < Tunit::Test
+  def test_pass
+    assert 2.even?
+  end
+
+  def test_pass_one_more
+    assert_includes [1, 2], 2
+  end
+
+  def test_empty
+  end
+
+  def test_skip
+    skip
+  end
+
+  def test_skip_with_message
+    skip 'here!'
+  end
+end

data/lib/tunit.rb

@@ -0,0 +1,83 @@
+require "tunit/compound_reporter"
+require "tunit/summary_reporter"
+require "tunit/progress_reporter"
+require "tunit/test"
+require "tunit/version"
+
+require 'optparse'
+
+module Tunit
+  meta_klass = (class << self; self; end)
+  meta_klass.send :attr_accessor, :reporter
+
+  # Let io be override-able in tests
+  meta_klass.send :attr_accessor, :io
+  self.io = $stdout
+
+  # Make sure that autorun is loaded after each test class has been loaded
+  meta_klass.send :attr_accessor, :installed_at_exit
+  self.installed_at_exit ||= false
+
+  def self.autorun
+    at_exit {
+      next if $! and not ($!.kind_of? SystemExit and $!.success?)
+
+      exit_code = nil
+
+      at_exit {
+        exit exit_code || false
+      }
+
+      exit_code = Tunit.run ARGV
+    } unless self.installed_at_exit
+    self.installed_at_exit = true
+  end
+
+  def self.run args = []
+    options = process_args! args
+
+    self.reporter = CompoundReporter.new
+    reporter << SummaryReporter.new(options[:io], options)
+    reporter << ProgressReporter.new(options[:io], options)
+
+    reporter.start
+    dispatch! reporter, options
+    reporter.report
+
+    reporter.passed?
+  end
+
+  private
+
+  def self.dispatch! reporter, options
+    Runnable.runnables.each do |runnable|
+      runnable.run reporter, options
+    end
+  end
+
+  def self.process_args! args = []
+    options = { io: io }
+
+    OptionParser.new do |opts|
+      opts.banner  = "Tunit options:"
+      opts.version = Tunit::VERSION
+
+      opts.on "-h", "--help", "Display this help." do
+        puts opts
+        exit
+      end
+
+      opts.on "-n", "--name PATTERN", "Filter run on /pattern/ or string." do |pattern|
+        options[:filter] = pattern
+      end
+
+      opts.on "-v", "--verbose", "Verbose. Show progress processing files." do
+        options[:verbose] = true
+      end
+
+      opts.parse! args
+    end
+
+    options
+  end
+end

data/lib/tunit/assertion_errors.rb

@@ -0,0 +1,43 @@
+module Tunit
+  class Assertion < Exception
+    def error
+      self
+    end
+
+    def location
+      last_before_assertion = ""
+      self.backtrace.reverse_each do |line|
+        break if line =~ /in .(assert|refute|pass|raise)/
+        last_before_assertion = line
+      end
+      last_before_assertion.sub(/:in .*$/, "")
+    end
+
+    def result_code
+      result_label[0, 1]
+    end
+
+    def result_label
+      "Failure"
+    end
+  end
+
+  class Empty < Assertion
+    # Where was the empty test
+    attr_accessor :location
+
+    def result_code
+      "_"
+    end
+
+    def result_label
+      "Empty"
+    end
+  end
+
+  class Skip < Assertion
+    def result_label
+      "Skipped"
+    end
+  end
+end

data/lib/tunit/assertions.rb

@@ -0,0 +1,68 @@
+require 'tunit/assertion_errors'
+
+module Tunit
+  module Assertions
+    def skip msg = nil, bt = caller
+      method_responsible = bt[0][/`.*'/][1..-2]
+      msg ||= "Skipped '#{method_responsible}'"
+      fail ::Tunit::Skip, msg, bt
+    end
+
+    def assert test, msg = nil
+      msg ||= "Failed assertion, no message given."
+      self.assertions += 1
+      unless test
+        msg = msg.call if Proc === msg
+        fail ::Tunit::Assertion, msg
+      end
+      true
+    end
+
+    def assert_equal exp, act, msg = nil
+      msg ||= "Failed assertion, no message given."
+      assert exp == act, msg
+    end
+
+    def assert_includes collection, obj, msg = nil
+      msg ||= "Expected #{collection.inspect} to include #{obj}"
+      assert_respond_to collection, :include?
+      assert collection.include?(obj), msg
+    end
+
+    def assert_respond_to obj, meth, msg = nil
+      msg ||= "Expected #{obj.inspect} (#{obj.class}) to respond to ##{meth}"
+      assert obj.respond_to?(meth), msg
+    end
+
+    def assert_instance_of klass, obj, msg = nil
+      msg ||= "Expected #{obj.inspect} to be an instance of #{klass}, not #{obj.class}"
+      assert obj.instance_of?(klass), msg
+    end
+
+    def refute test, msg = nil
+      msg ||= "Failed assertion, no message given."
+      ! assert !test, msg
+    end
+
+    def refute_equal exp, act, msg = nil
+      msg ||= "Failed assertion, no message given."
+      refute exp == act, msg
+    end
+
+    def refute_includes collection, obj, msg = nil
+      msg ||= "Expected #{collection.inspect} to not include #{obj}"
+      assert_respond_to collection, :include?
+      refute collection.include?(obj), msg
+    end
+
+    def refute_respond_to obj, meth, msg = nil
+      msg ||= "Expected #{obj.inspect} (#{obj.class}) to not respond to #{meth}"
+      refute obj.respond_to?(meth), msg
+    end
+
+    def refute_instance_of klass, obj, msg = nil
+      msg ||= "Expected #{obj.inspect} not to be an instance of #{klass}"
+      refute obj.instance_of?(klass), msg
+    end
+  end
+end

data/lib/tunit/autorun.rb

@@ -0,0 +1,8 @@
+require "tunit/test"
+require "tunit/spec"
+require "tunit/compound_reporter"
+require "tunit/summary_reporter"
+require "tunit/progress_reporter"
+require "tunit"
+
+Tunit.autorun