csd 0.0.15 → 0.0.16

data/lib/active_support/testing/declarative.rb

@@ -0,0 +1,40 @@
+module ActiveSupport
+  module Testing
+    module Declarative
+      
+      def self.extended(klass)
+        klass.class_eval do
+          
+          unless method_defined?(:describe)
+            def self.describe(text)
+              class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+                def self.name
+                  "#{text}"
+                end
+              RUBY_EVAL
+            end
+          end
+          
+        end
+      end 
+
+      unless defined?(Spec)
+        # test "verify something" do
+        #   ...
+        # end
+        def test(name, &block)
+          test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+          defined = instance_method(test_name) rescue false
+          raise "#{test_name} is already defined in #{self}" if defined
+          if block_given?
+            define_method(test_name, &block)
+          else
+            define_method(test_name) do
+              flunk "No implementation provided for #{name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_support/testing/default.rb

@@ -0,0 +1,9 @@
+module ActiveSupport
+  module Testing
+    module Default #:nodoc:
+      # Placeholder so test/unit ignores test cases without any tests.
+      def default_test
+      end
+    end
+  end
+end

data/lib/active_support/testing/deprecation.rb

@@ -0,0 +1,55 @@
+require 'active_support/deprecation'
+
+module ActiveSupport
+  module Testing
+    module Deprecation #:nodoc:
+      def assert_deprecated(match = nil, &block)
+        result, warnings = collect_deprecations(&block)
+        assert !warnings.empty?, "Expected a deprecation warning within the block but received none"
+        if match
+          match = Regexp.new(Regexp.escape(match)) unless match.is_a?(Regexp)
+          assert warnings.any? { |w| w =~ match }, "No deprecation warning matched #{match}: #{warnings.join(', ')}"
+        end
+        result
+      end
+
+      def assert_not_deprecated(&block)
+        result, deprecations = collect_deprecations(&block)
+        assert deprecations.empty?, "Expected no deprecation warning within the block but received #{deprecations.size}: \n  #{deprecations * "\n  "}"
+        result
+      end
+
+      private
+        def collect_deprecations
+          old_behavior = ActiveSupport::Deprecation.behavior
+          deprecations = []
+          ActiveSupport::Deprecation.behavior = Proc.new do |message, callstack|
+            deprecations << message
+          end
+          result = yield
+          [result, deprecations]
+        ensure
+          ActiveSupport::Deprecation.behavior = old_behavior
+        end
+    end
+  end
+end
+
+begin
+  require 'test/unit/error'
+rescue LoadError
+  # Using miniunit, ignore.
+else
+  module Test
+    module Unit
+      class Error #:nodoc:
+        # Silence warnings when reporting test errors.
+        def message_with_silenced_deprecation
+          ActiveSupport::Deprecation.silence { message_without_silenced_deprecation }
+        end
+        alias_method :message_without_silenced_deprecation, :message
+        alias_method :message, :message_with_silenced_deprecation
+      end
+    end
+  end
+end

data/lib/active_support/testing/isolation.rb

@@ -0,0 +1,154 @@
+require 'rbconfig'
+module ActiveSupport
+  module Testing
+    class RemoteError < StandardError
+
+      attr_reader :message, :backtrace
+
+      def initialize(exception)
+        @message = "caught #{exception.class.name}: #{exception.message}"
+        @backtrace = exception.backtrace
+      end
+    end
+
+    class ProxyTestResult
+      def initialize
+        @calls = []
+      end
+
+      def add_error(e)
+        e = Test::Unit::Error.new(e.test_name, RemoteError.new(e.exception))
+        @calls << [:add_error, e]
+      end
+
+      def __replay__(result)
+        @calls.each do |name, args|
+          result.send(name, *args)
+        end
+      end
+
+      def method_missing(name, *args)
+        @calls << [name, args]
+      end
+    end
+
+    module Isolation
+      def self.forking_env?
+        !ENV["NO_FORK"] && ((Config::CONFIG['host_os'] !~ /mswin|mingw/) && (RUBY_PLATFORM !~ /java/))
+      end
+
+      def self.included(base)
+        if defined?(::MiniTest) && base < ::MiniTest::Unit::TestCase
+          base.send :include, MiniTest
+        elsif defined?(Test::Unit)
+          base.send :include, TestUnit
+        end
+      end
+
+      module TestUnit
+        def run(result)
+          unless defined?(@@ran_class_setup)
+            self.class.setup if self.class.respond_to?(:setup)
+            @@ran_class_setup = true
+          end
+
+          yield(Test::Unit::TestCase::STARTED, name)
+
+          @_result = result
+
+          serialized = run_in_isolation do |proxy|
+            begin
+              super(proxy) { }
+            rescue Exception => e
+              proxy.add_error(Test::Unit::Error.new(name, e))
+            end
+          end
+
+          retval, proxy = Marshal.load(serialized)
+          proxy.__replay__(@_result)
+
+          yield(Test::Unit::TestCase::FINISHED, name)
+          retval
+        end
+      end
+
+      module MiniTest
+        def run(runner)
+          unless defined?(@@ran_class_setup)
+            self.class.setup if self.class.respond_to?(:setup)
+            @@ran_class_setup = true
+          end
+
+          serialized = run_in_isolation do |isolated_runner|
+            super(isolated_runner)
+          end
+
+          retval, proxy = Marshal.load(serialized)
+          proxy.__replay__(runner)
+          retval
+        end
+      end
+
+      module Forking
+        def run_in_isolation(&blk)
+          read, write = IO.pipe
+
+          pid = fork do
+            read.close
+            proxy = ProxyTestResult.new
+            retval = yield proxy
+            write.puts [Marshal.dump([retval, proxy])].pack("m")
+            exit!
+          end
+
+          write.close
+          result = read.read
+          Process.wait2(pid)
+          return result.unpack("m")[0]
+        end
+      end
+
+      module Subprocess
+        # Crazy H4X to get this working in windows / jruby with
+        # no forking.
+        def run_in_isolation(&blk)
+          require "tempfile"
+
+          if ENV["ISOLATION_TEST"]
+            proxy = ProxyTestResult.new
+            retval = yield proxy
+            File.open(ENV["ISOLATION_OUTPUT"], "w") do |file|
+              file.puts [Marshal.dump([retval, proxy])].pack("m")
+            end
+            exit!
+          else
+            Tempfile.open("isolation") do |tmpfile|
+              ENV["ISOLATION_TEST"]   = @method_name
+              ENV["ISOLATION_OUTPUT"] = tmpfile.path
+
+              load_paths = $-I.map {|p| "-I\"#{File.expand_path(p)}\"" }.join(" ")
+              `#{Gem.ruby} #{load_paths} #{$0} #{ORIG_ARGV.join(" ")} -t\"#{self.class}\"`
+
+              ENV.delete("ISOLATION_TEST")
+              ENV.delete("ISOLATION_OUTPUT")
+
+              return tmpfile.read.unpack("m")[0]
+            end
+          end
+        end
+      end
+
+      include forking_env? ? Forking : Subprocess
+    end
+  end
+end
+
+# Only in subprocess for windows / jruby.
+if ENV['ISOLATION_TEST']
+  require "test/unit/collector/objectspace"
+  class Test::Unit::Collector::ObjectSpace
+    def include?(test)
+      super && test.method_name == ENV['ISOLATION_TEST']
+    end
+  end
+end

data/lib/active_support/testing/pending.rb

@@ -0,0 +1,48 @@
+# Some code from jeremymcanally's "pending"
+# http://github.com/jeremymcanally/pending/tree/master
+
+module ActiveSupport
+  module Testing
+    module Pending
+
+      unless defined?(Spec)
+
+        @@pending_cases = []
+        @@at_exit = false
+
+        def pending(description = "", &block)
+          if description.is_a?(Symbol)
+            is_pending = $tags[description]
+            return block.call unless is_pending
+          end
+
+          if block_given?
+            failed = false
+
+            begin
+              block.call
+            rescue Exception
+              failed = true
+            end
+
+            flunk("<#{description}> did not fail.") unless failed 
+          end
+
+          caller[0] =~ (/(.*):(.*):in `(.*)'/)
+          @@pending_cases << "#{$3} at #{$1}, line #{$2}"
+          print "P"
+      
+          @@at_exit ||= begin
+            at_exit do
+              puts "\nPending Cases:"
+              @@pending_cases.each do |test_case|
+                puts test_case
+              end
+            end
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/active_support/testing/performance.rb

@@ -0,0 +1,455 @@
+begin
+  require 'ruby-prof'
+
+  require 'fileutils'
+  require 'rails/version'
+  require 'active_support/core_ext/class/delegating_attributes'
+  require 'active_support/core_ext/string/inflections'
+
+  module ActiveSupport
+    module Testing
+      module Performance
+        DEFAULTS =
+          if benchmark = ARGV.include?('--benchmark')  # HAX for rake test
+            { :benchmark => true,
+              :runs => 4,
+              :metrics => [:wall_time, :memory, :objects, :gc_runs, :gc_time],
+              :output => 'tmp/performance' }
+          else
+            { :benchmark => false,
+              :runs => 1,
+              :min_percent => 0.01,
+              :metrics => [:process_time, :memory, :objects],
+              :formats => [:flat, :graph_html, :call_tree],
+              :output => 'tmp/performance' }
+          end.freeze
+
+        def self.included(base)
+          base.superclass_delegating_accessor :profile_options
+          base.profile_options = DEFAULTS
+        end
+
+        def full_test_name
+          "#{self.class.name}##{method_name}"
+        end
+
+        def run(result)
+          return if method_name =~ /^default_test$/
+
+          yield(self.class::STARTED, name)
+          @_result = result
+
+          run_warmup
+          if profile_options && metrics = profile_options[:metrics]
+            metrics.each do |metric_name|
+              if klass = Metrics[metric_name.to_sym]
+                run_profile(klass.new)
+                result.add_run
+              end
+            end
+          end
+
+          yield(self.class::FINISHED, name)
+        end
+
+        def run_test(metric, mode)
+          run_callbacks :setup
+          setup
+          metric.send(mode) { __send__ @method_name }
+        rescue ::Test::Unit::AssertionFailedError => e
+          add_failure(e.message, e.backtrace)
+        rescue StandardError, ScriptError
+          add_error($!)
+        ensure
+          begin
+            teardown
+            run_callbacks :teardown, :enumerator => :reverse_each
+          rescue ::Test::Unit::AssertionFailedError => e
+            add_failure(e.message, e.backtrace)
+          rescue StandardError, ScriptError
+            add_error($!)
+          end
+        end
+
+        protected
+          def run_warmup
+            GC.start
+
+            time = Metrics::Time.new
+            run_test(time, :benchmark)
+            puts "%s (%s warmup)" % [full_test_name, time.format(time.total)]
+
+            GC.start
+          end
+
+          def run_profile(metric)
+            klass = profile_options[:benchmark] ? Benchmarker : Profiler
+            performer = klass.new(self, metric)
+
+            performer.run
+            puts performer.report
+            performer.record
+          end
+
+        class Performer
+          delegate :run_test, :profile_options, :full_test_name, :to => :@harness
+
+          def initialize(harness, metric)
+            @harness, @metric = harness, metric
+          end
+
+          def report
+            rate = @total / profile_options[:runs]
+            '%20s: %s' % [@metric.name, @metric.format(rate)]
+          end
+
+          protected
+            def output_filename
+              "#{profile_options[:output]}/#{full_test_name}_#{@metric.name}"
+            end
+        end
+
+        class Benchmarker < Performer
+          def run
+            profile_options[:runs].to_i.times { run_test(@metric, :benchmark) }
+            @total = @metric.total
+          end
+
+          def record
+            avg = @metric.total / profile_options[:runs].to_i
+            now = Time.now.utc.xmlschema
+            with_output_file do |file|
+              file.puts "#{avg},#{now},#{environment}"
+            end
+          end
+
+          def environment
+            unless defined? @env
+              app = "#{$1}.#{$2}" if File.directory?('.git') && `git branch -v` =~ /^\* (\S+)\s+(\S+)/
+
+              rails = Rails::VERSION::STRING
+              if File.directory?('vendor/rails/.git')
+                Dir.chdir('vendor/rails') do
+                  rails += ".#{$1}.#{$2}" if `git branch -v` =~ /^\* (\S+)\s+(\S+)/
+                end
+              end
+
+              ruby = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
+              ruby += "-#{RUBY_VERSION}.#{RUBY_PATCHLEVEL}"
+
+              @env = [app, rails, ruby, RUBY_PLATFORM] * ','
+            end
+
+            @env
+          end
+
+          protected
+            HEADER = 'measurement,created_at,app,rails,ruby,platform'
+
+            def with_output_file
+              fname = output_filename
+
+              if new = !File.exist?(fname)
+                FileUtils.mkdir_p(File.dirname(fname))
+              end
+
+              File.open(fname, 'ab') do |file|
+                file.puts(HEADER) if new
+                yield file
+              end
+            end
+
+            def output_filename
+              "#{super}.csv"
+            end
+        end
+
+        class Profiler < Performer
+          def initialize(*args)
+            super
+            @supported = @metric.measure_mode rescue false
+          end
+
+          def run
+            return unless @supported
+
+            RubyProf.measure_mode = @metric.measure_mode
+            RubyProf.start
+            RubyProf.pause
+            profile_options[:runs].to_i.times { run_test(@metric, :profile) }
+            @data = RubyProf.stop
+            @total = @data.threads.values.sum(0) { |method_infos| method_infos.sort.last.total_time }
+          end
+
+          def report
+            if @supported
+              super
+            else
+              '%20s: unsupported' % @metric.name
+            end
+          end
+
+          def record
+            return unless @supported
+
+            klasses = profile_options[:formats].map { |f| RubyProf.const_get("#{f.to_s.camelize}Printer") }.compact
+
+            klasses.each do |klass|
+              fname = output_filename(klass)
+              FileUtils.mkdir_p(File.dirname(fname))
+              File.open(fname, 'wb') do |file|
+                klass.new(@data).print(file, profile_options.slice(:min_percent))
+              end
+            end
+          end
+
+          protected
+            def output_filename(printer_class)
+              suffix =
+                case printer_class.name.demodulize
+                  when 'FlatPrinter'; 'flat.txt'
+                  when 'GraphPrinter'; 'graph.txt'
+                  when 'GraphHtmlPrinter'; 'graph.html'
+                  when 'CallTreePrinter'; 'tree.txt'
+                  else printer_class.name.sub(/Printer$/, '').underscore
+                end
+
+              "#{super()}_#{suffix}"
+            end
+        end
+
+        module Metrics
+          def self.[](name)
+            const_get(name.to_s.camelize)
+          rescue NameError
+            nil
+          end
+
+          class Base
+            attr_reader :total
+
+            def initialize
+              @total = 0
+            end
+
+            def name
+              @name ||= self.class.name.demodulize.underscore
+            end
+
+            def measure_mode
+              self.class::Mode
+            end
+
+            def measure
+              0
+            end
+
+            def benchmark
+              with_gc_stats do
+                before = measure
+                yield
+                @total += (measure - before)
+              end
+            end
+
+            def profile
+              RubyProf.resume
+              yield
+            ensure
+              RubyProf.pause
+            end
+
+            protected
+              if GC.respond_to?(:enable_stats)
+                def with_gc_stats
+                  GC.enable_stats
+                  yield
+                ensure
+                  GC.disable_stats
+                end
+              elsif defined?(GC::Profiler)
+                def with_gc_stats
+                  GC.start
+                  GC.disable
+                  GC::Profiler.enable
+                  yield
+                ensure
+                  GC::Profiler.disable
+                  GC.enable
+                end
+              else
+                def with_gc_stats
+                  yield
+                end
+              end
+          end
+
+          class Time < Base
+            def measure
+              ::Time.now.to_f
+            end
+
+            def format(measurement)
+              if measurement < 2
+                '%d ms' % (measurement * 1000)
+              else
+                '%.2f sec' % measurement
+              end
+            end
+          end
+
+          class ProcessTime < Time
+            Mode = RubyProf::PROCESS_TIME
+
+            def measure
+              RubyProf.measure_process_time
+            end
+          end
+
+          class WallTime < Time
+            Mode = RubyProf::WALL_TIME
+
+            def measure
+              RubyProf.measure_wall_time
+            end
+          end
+
+          class CpuTime < Time
+            Mode = RubyProf::CPU_TIME if RubyProf.const_defined?(:CPU_TIME)
+
+            def initialize(*args)
+              # FIXME: yeah my CPU is 2.33 GHz
+              RubyProf.cpu_frequency = 2.33e9
+              super
+            end
+
+            def measure
+              RubyProf.measure_cpu_time
+            end
+          end
+
+          class Memory < Base
+            Mode = RubyProf::MEMORY if RubyProf.const_defined?(:MEMORY)
+
+            # ruby-prof wrapper
+            if RubyProf.respond_to?(:measure_memory)
+              def measure
+                RubyProf.measure_memory / 1024.0
+              end
+
+            # Ruby 1.8 + railsbench patch
+            elsif GC.respond_to?(:allocated_size)
+              def measure
+                GC.allocated_size / 1024.0
+              end
+
+            # Ruby 1.8 + lloyd patch
+            elsif GC.respond_to?(:heap_info)
+              def measure
+                GC.heap_info['heap_current_memory'] / 1024.0
+              end
+
+            # Ruby 1.9 with total_malloc_allocated_size patch
+            elsif GC.respond_to?(:malloc_total_allocated_size)
+              def measure
+                GC.total_malloc_allocated_size / 1024.0
+              end
+
+            # Ruby 1.9 unpatched
+            elsif GC.respond_to?(:malloc_allocated_size)
+              def measure
+                GC.malloc_allocated_size / 1024.0
+              end
+
+            # Ruby 1.9 + GC profiler patch
+            elsif defined?(GC::Profiler)
+              def measure
+                GC.enable
+                GC.start
+                kb = GC::Profiler.data.last[:HEAP_USE_SIZE] / 1024.0
+                GC.disable
+                kb
+              end
+            end
+
+            def format(measurement)
+              '%.2f KB' % measurement
+            end
+          end
+
+          class Objects < Base
+            Mode = RubyProf::ALLOCATIONS if RubyProf.const_defined?(:ALLOCATIONS)
+
+            if RubyProf.respond_to?(:measure_allocations)
+              def measure
+                RubyProf.measure_allocations
+              end
+
+            # Ruby 1.8 + railsbench patch
+            elsif ObjectSpace.respond_to?(:allocated_objects)
+              def measure
+                ObjectSpace.allocated_objects
+              end
+
+            # Ruby 1.9 + GC profiler patch
+            elsif defined?(GC::Profiler)
+              def measure
+                GC.enable
+                GC.start
+                last = GC::Profiler.data.last
+                count = last[:HEAP_LIVE_OBJECTS] + last[:HEAP_FREE_OBJECTS]
+                GC.disable
+                count
+              end
+            end
+
+            def format(measurement)
+              measurement.to_i.to_s
+            end
+          end
+
+          class GcRuns < Base
+            Mode = RubyProf::GC_RUNS if RubyProf.const_defined?(:GC_RUNS)
+
+            if RubyProf.respond_to?(:measure_gc_runs)
+              def measure
+                RubyProf.measure_gc_runs
+              end
+            elsif GC.respond_to?(:collections)
+              def measure
+                GC.collections
+              end
+            elsif GC.respond_to?(:heap_info)
+              def measure
+                GC.heap_info['num_gc_passes']
+              end
+            end
+
+            def format(measurement)
+              measurement.to_i.to_s
+            end
+          end
+
+          class GcTime < Base
+            Mode = RubyProf::GC_TIME if RubyProf.const_defined?(:GC_TIME)
+
+            if RubyProf.respond_to?(:measure_gc_time)
+              def measure
+                RubyProf.measure_gc_time
+              end
+            elsif GC.respond_to?(:time)
+              def measure
+                GC.time
+              end
+            end
+
+            def format(measurement)
+              '%d ms' % (measurement / 1000)
+            end
+          end
+        end
+      end
+    end
+  end
+rescue LoadError
+end