cwninja-drunit 0.1

data/README.markdown

@@ -0,0 +1,32 @@
+# Distributed Ruby Unit (Testing)
+
+A library for running tests across multiple applications from a single test case.
+
+
+## Basic usage:
+
+    class MainTest < Test::Unit::TestCase
+      include Drunit
+      RemoteApp(:fake_app, FAKE_APP_PATH + "/fake_app.rb")
+      RemoteApp(:rails_app, RAILS_APP_PATH + "/script/runner")
+
+      def test_should_use_the_same_db
+        id = in_app(:fake_app){
+          User.create!(:name => "Some Name")
+        }
+
+        in_app(:rails_app, id) do |id|
+          assert_nothing_raised() { User.find(id) }
+        end
+      end
+    end
+
+## Other "features"
+* Automatically "Brings Up" and "Takes Down" your apps as needed. (Uses GC to tell when it's no longer needed.)
+* Tracking of assertion counts.
+* Beautified (a little) backtraces.
+* Line number preserving between apps.
+* Packed full of bugs (probably, I'm not sure).
+* Packed full of 1.9 incompatibilities (I'm assuming).
+* Packed full of space ninjas.
+* Over 14% more awesome than a bag of chips.

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'date'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'run tests.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+spec = Gem::Specification.new do |s|
+  s.name        = %q{drunit}
+  s.version     = "0.1"
+  s.summary     = %q{A library for running tests across multiple applications from a single test case.}
+  s.description = %q{A library for running tests across multiple applications from a single test case.}
+
+  s.files        = FileList['[A-Z]*', 'lib/**/*.rb', 'test/**/*.rb', 'rails/*']
+  s.executables  = "drunit_remote"
+  s.require_path = 'lib'
+  s.test_files   = Dir[*['test/**/*_test.rb']]
+
+  s.has_rdoc         = true
+  s.extra_rdoc_files = ["README.markdown"]
+  s.rdoc_options = ['--line-numbers', '--inline-source', "--main", "README.markdown"]
+
+  s.authors = ["Tom Lea"]
+  s.email   = %q{commits@tomlea.co.uk}
+
+  s.platform = Gem::Platform::RUBY
+end
+
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+  pkg.need_zip = true
+end
+
+desc "Clean files generated by rake tasks"
+task :clobber => [:clobber_rdoc, :clobber_package]
+
+desc "Generate a gemspec file"
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end

data/bin/drunit_remote

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), *%w[.. lib drunit remote_test])
+
+include Drunit
+require ARGV.first
+
+DRb.start_service nil, RemoteTest.new
+
+STDOUT.puts DRb.uri
+STDOUT.reopen(STDERR)
+
+load ARGV.shift
+
+DRb.thread.join

data/lib/drunit.rb

@@ -0,0 +1,46 @@
+module Drunit
+  class RemoteError < RuntimeError
+    def self.name
+      @@name
+    end
+
+    def class
+      if type = look_up_exception
+        return type
+      else
+        @@name = @real_exception.to_s
+        super
+      end
+    end
+
+    def look_up_exception
+      @real_exception.split("::").inject(Object){|node, part|
+        node && node.const_defined?(part) && node.const_get(part)
+      }
+    end
+  end
+
+  module ClassMethods
+    def RemoteApp(name, *args)
+      const_set "RemoteAppFor_#{name}", RemoteApp.new(name, *args)
+    end
+  end
+
+  def in_app(name, *args, &block)
+    file, line, method = caller(2).first.split(":")
+    remote_app_for(name).run(method.gsub(/^in /, "").gsub(/[^a-zA-Z0-9_?!]/, ""), file, line.to_i, *args, &block)
+  ensure
+    remote_app_for(name).last_assertion_count.times{ add_assertion } rescue nil
+  end
+
+  def remote_app_for(name)
+    self.class.const_get("RemoteAppFor_#{name}")
+  end
+
+  def self.included(other)
+    other.send(:extend, ClassMethods)
+  end
+end
+
+require File.join(File.dirname(__FILE__), *%w[drunit remote_app])
+

data/lib/drunit/remote_app.rb

@@ -0,0 +1,52 @@
+require 'drb'
+require 'ruby2ruby'
+
+module Drunit
+  class RemoteApp
+    def initialize(name, boot = nil)
+      @name = name
+      @boot = boot
+      @boot ||= "#{name}/test/drunit_test_helper.rb" if File.exist? "#{name}/test/drunit_test_helper.rb"
+      @boot ||= "#{name}/test/test_helper.rb" if File.exist? "#{name}/test/test_helper.rb"
+      @remote_object = nil
+    end
+
+    def run(method_name, file, line, *args, &block)
+      raise_or_return(app.eval(block_to_source(method_name, &block), file, line, method_name, *args), method_name)
+    end
+
+    def last_assertion_count
+      app.last_assertion_count
+    end
+
+  private
+    def raise_or_return(e, method_name)
+      return e unless e.is_a? Exception
+      if first_remote_line = e.backtrace.grep(Regexp.new(method_name)).last
+        index = e.backtrace.index(first_remote_line)
+        raise e, e.message, e.backtrace[0..index] + ["RemoteApp<#{@name}>"] + caller(0)
+      end
+      raise e
+    end
+
+    def start_app!
+      drb_server = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "bin", "drunit_remote"))
+      pipe = IO.popen("#{drb_server} #{@boot}")
+      pid = pipe.pid
+      url = pipe.gets.chomp
+      remote_object = DRbObject.new(nil, url)
+      ObjectSpace.define_finalizer(remote_object, proc{|id| Process.kill("KILL", pid) && Process.wait})
+      return remote_object
+    end
+
+    def app
+      @remote_object ||= start_app!
+    end
+
+    def block_to_source(method_name, &block)
+      m = Module.new
+      m.send(:define_method, method_name, &block)
+      Ruby2Ruby.translate(m, method_name)
+    end
+  end
+end

data/lib/drunit/remote_test.rb

@@ -0,0 +1,54 @@
+require 'drb'
+require 'test/unit'
+
+module Drunit
+  class RemoteError < RuntimeError
+    def initialize(real_exception)
+      @real_exception = real_exception
+    end
+  end
+
+  class RemoteTest
+    attr_reader :last_assertion_count
+
+    class TestCase
+      include Test::Unit::Assertions
+      attr_reader :assertion_count
+
+      def initialize(code, source_file, source_line, method_name)
+        @assertion_count = 0
+        @method_name = method_name
+        instance_eval(code, source_file, source_line)
+      end
+
+      def add_assertion
+        @assertion_count += 1
+      end
+
+      def run(*args)
+        send(@method_name, *args)
+      end
+    end
+
+    def eval(code, source_file, source_line, method_name, *args)
+      test_case = TestCase.new(code, source_file, source_line, method_name)
+      return rewrite_exceptions{ test_case.run(*args) }
+    rescue Exception => e
+      return e
+    ensure
+      @last_assertion_count = defined?(test_case.assertion_count) ? test_case.assertion_count : 0
+    end
+  private
+    # We need to strib down and generalise the exceptions to prevent the integration project from having to know anything about anything.
+    def rewrite_exceptions
+      return yield
+    rescue Test::Unit::AssertionFailedError
+      raise
+    rescue ArgumentError => e
+      raise e unless e.message =~ /Anonymous modules /
+      raise NameError, "Const Missing", e.backtrace[3..-1]
+    rescue Exception => e
+      raise Drunit::RemoteError.new(e.class.name), e.message, e.backtrace
+    end
+  end
+end

data/test/fake_app/fake_app.rb

@@ -0,0 +1,13 @@
+class SomeFoo
+  def multiply(a,b)
+    a * b
+  end
+end
+
+class SomeException < Exception
+end
+
+module MyModule
+  class SomeOtherException < Exception
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require "test/unit"
+require "drunit"
+
+FAKE_APP_PATH = File.join(File.dirname(__FILE__), *%w[fake_app])

data/test/unit/main_test.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), *%w[.. test_helper])
+
+class MainTest < Test::Unit::TestCase
+  include Drunit
+  RemoteApp(:fake_app, FAKE_APP_PATH + "/fake_app.rb")
+  def InApp(*args, &block)
+    in_app(:fake_app, *args, &block)
+  end
+
+  def test_should_not_raise_in_a_basic_case
+    InApp do
+      assert true
+    end
+  end
+
+  def test_should_raise_an_exception
+    assert_raise(RuntimeError) { InApp{ raise "Fail" } }
+  end
+
+  def test_should_raise_an_exception_faking_its_class_name_if_we_have_never_heard_of_it
+    InApp{ raise SomeException, "Fooo" }
+    flunk "Should have raised."
+  rescue => e
+    assert_equal "SomeException", e.class.name
+  end
+
+  def test_should_inject_the_fact_we_are_in_a_remote_app_into_the_backtrace
+    e = assert_raise(RuntimeError) { InApp{ raise "Fail" } }
+    assert_equal 1, e.backtrace.grep("RemoteApp<fake_app>").size
+  end
+
+  def test_should_raise_the_assertion_count_when_we_assert
+    original_count = @_result.assertion_count
+    InApp{ assert true}
+    assert_equal original_count + 1, @_result.assertion_count
+  end
+
+  def test_should_be_able_to_pass_in_simple_params
+    assert_equal 12, InApp(2,6){|a,b| SomeFoo.new.multiply(a, b)}
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification 
+name: cwninja-drunit
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Tom Lea
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-26 00:00:00 -08:00
+default_executable: drunit_remote
+dependencies: []
+
+description: A library for running tests across multiple applications from a single test case.
+email: commits@tomlea.co.uk
+executables: 
+- drunit_remote
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- Rakefile
+- README.markdown
+- lib/drunit/remote_app.rb
+- lib/drunit/remote_test.rb
+- lib/drunit.rb
+- test/fake_app/fake_app.rb
+- test/test_helper.rb
+- test/unit/main_test.rb
+- bin/drunit_remote
+has_rdoc: true
+homepage: 
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A library for running tests across multiple applications from a single test case.
+test_files: 
+- test/unit/main_test.rb