causes-hydra 0.21.0

data/lib/hydra/message/master_messages.rb

@@ -0,0 +1,19 @@
+module Hydra #:nodoc:
+  module Messages #:nodoc:
+    module Master #:nodoc:
+      # Message telling a worker to delegate a file to a runner
+      class RunFile < Hydra::Messages::Worker::RunFile
+        def handle(worker) #:nodoc:
+          worker.delegate_file(self)
+        end
+      end
+
+      # Message telling the worker to shut down.
+      class Shutdown < Hydra::Messages::Worker::Shutdown
+        def handle(worker) #:nodoc:
+          worker.shutdown
+        end
+      end
+    end
+  end
+end

data/lib/hydra/message/runner_messages.rb

@@ -0,0 +1,52 @@
+module Hydra #:nodoc:
+  module Messages #:nodoc:
+    module Runner #:nodoc:
+      # Message indicating that a Runner needs a file to run
+      class RequestFile < Hydra::Message
+        def handle(worker, runner) #:nodoc:
+          worker.request_file(self, runner)
+        end
+      end
+
+      # Message for the Runner to respond with its results
+      class Results < Hydra::Message
+        # The output from running the test
+        attr_accessor :output
+        # The file that was run
+        attr_accessor :file
+        # Stats on the number of tests, assertions, errors and failures
+        attr_accessor :stats
+        def serialize #:nodoc:
+          super(
+            :output => @output,
+            :file   => @file,
+            :stats  => @stats
+          )
+        end
+        def handle(worker, runner) #:nodoc:
+          worker.relay_results(self, runner)
+        end
+      end
+
+      # Message a runner sends to a worker to verify the connection
+      class Ping < Hydra::Message
+        def handle(worker, runner) #:nodoc:
+          # We don't do anything to handle a ping. It's just to test
+          # the connectivity of the IO
+        end
+      end
+
+      # The runner forks to run rspec messages
+      # so that specs don't get rerun. It uses
+      # this message to report the results. See
+      # Runner::run_rspec_file.
+      class RSpecResult < Hydra::Message
+        # the output of the spec
+        attr_accessor :output
+        def serialize #:nodoc:
+          super(:output => @output)
+        end
+      end
+    end
+  end
+end

data/lib/hydra/message/worker_messages.rb

@@ -0,0 +1,52 @@
+module Hydra #:nodoc: 
+  module Messages #:nodoc:
+    module Worker #:nodoc:
+      # Message indicating that a worker needs a file to delegate to a runner
+      class RequestFile < Hydra::Message
+        def handle(master, worker) #:nodoc:
+          master.send_file(worker)
+        end
+      end
+
+      class WorkerBegin < Hydra::Message
+        def handle(master, worker)
+          master.worker_begin(worker)
+        end
+      end
+
+      # Message telling the Runner to run a file
+      class RunFile < Hydra::Message
+        # The file that should be run
+        attr_accessor :file
+        def serialize #:nodoc:
+          super(:file => @file)
+        end
+        def handle(runner) #:nodoc:
+          runner.run_file(@file)
+        end
+      end
+
+      # Message to tell the Runner to shut down
+      class Shutdown < Hydra::Message
+        def handle(runner) #:nodoc:
+          runner.stop
+        end
+      end
+
+      # Message relaying the results of a worker up to the master
+      class Results < Hydra::Messages::Runner::Results
+        def handle(master, worker) #:nodoc:
+          master.process_results(worker, self)
+        end
+      end
+
+      # Message a worker sends to a master to verify the connection
+      class Ping < Hydra::Message
+        def handle(master, worker) #:nodoc:
+          # We don't do anything to handle a ping. It's just to test
+          # the connectivity of the IO
+        end
+      end
+    end
+  end
+end

data/lib/hydra/messaging_io.rb

@@ -0,0 +1,46 @@
+module Hydra #:nodoc:
+  # Module that implemets methods that auto-serialize and deserialize messaging
+  # objects.
+  module MessagingIO
+    # Read a Message from the input IO object. Automatically build
+    # a message from the response and return it.
+    #
+    #  IO.gets
+    #    => Hydra::Message # or subclass
+    def gets
+      raise IOError unless @reader
+      message = @reader.gets
+      return nil unless message
+      return Message.build(eval(message.chomp))
+    rescue SyntaxError, NameError
+      # uncomment to help catch remote errors by seeing all traffic
+      #$stderr.write "Not a message: [#{message.inspect}]\n"
+      return gets
+    end
+
+    # Write a Message to the output IO object. It will automatically
+    # serialize a Message object.
+    #  IO.write Hydra::Message.new
+    def write(message)
+      raise IOError unless @writer
+      raise UnprocessableMessage unless message.is_a?(Hydra::Message)
+      @writer.write(message.serialize+"\n")
+    rescue Errno::EPIPE
+      raise IOError
+    end
+
+    # Closes the IO object.
+    def close
+      @reader.close if @reader
+      @writer.close if @writer
+    end
+
+    # IO will return this error if it cannot process a message.
+    # For example, if you tried to write a string, it would fail,
+    # because the string is not a message.
+    class UnprocessableMessage < RuntimeError
+      # Custom error message
+      attr_accessor :message
+    end
+  end
+end

data/lib/hydra/pipe.rb

@@ -0,0 +1,61 @@
+require 'hydra/messaging_io'
+module Hydra #:nodoc:
+  # Read and write between two processes via pipes. For example:
+  #   @pipe = Hydra::Pipe.new
+  #   @child = Process.fork do
+  #     @pipe.identify_as_child
+  #     puts "A message from my parent:\n#{@pipe.gets.text}"
+  #     @pipe.close
+  #   end
+  #   @pipe.identify_as_parent
+  #   @pipe.write Hydra::Messages::TestMessage.new(:text => "Hello!")
+  #   @pipe.close
+  #
+  # Note that the TestMessage class is only available in tests, and
+  # not in Hydra by default.
+  #
+  #
+  # When the process forks, the pipe is copied. When a pipe is
+  # identified as a parent or child, it is choosing which ends
+  # of the pipe to use.
+  #
+  # A pipe is actually two pipes:
+  #
+  #  Parent  == Pipe 1 ==> Child
+  #  Parent <== Pipe 2 ==  Child
+  #
+  # It's like if you had two cardboard tubes and you were using
+  # them to drop balls with messages in them between processes.
+  # One tube is for sending from parent to child, and the other
+  # tube is for sending from child to parent.
+  class Pipe
+    include Hydra::MessagingIO
+    # Creates a new uninitialized pipe pair.
+    def initialize
+      @child_read, @parent_write = IO.pipe
+      @parent_read, @child_write = IO.pipe
+    end
+
+    # Identify this side of the pipe as the child.
+    def identify_as_child
+      @parent_write.close
+      @parent_read.close
+      @reader = @child_read
+      @writer = @child_write
+    end
+
+    # Identify this side of the pipe as the parent
+    def identify_as_parent
+      @child_write.close
+      @child_read.close
+      @reader = @parent_read
+      @writer = @parent_write
+    end
+
+    # Output pipe nicely
+    def inspect
+      "#<#{self.class} @reader=#{@reader.to_s}, @writer=#{@writer.to_s}>"
+    end
+
+  end
+end

data/lib/hydra/runner.rb

@@ -0,0 +1,305 @@
+require 'test/unit'
+require 'test/unit/testresult'
+Test::Unit.run = true
+
+module Hydra #:nodoc:
+  # Hydra class responsible for running test files.
+  #
+  # The Runner is never run directly by a user. Runners are created by a
+  # Worker to run test files.
+  #
+  # The general convention is to have one Runner for each logical processor
+  # of a machine.
+  class Runner
+    include Hydra::Messages::Runner
+    traceable('RUNNER')
+    # Boot up a runner. It takes an IO object (generally a pipe from its
+    # parent) to send it messages on which files to execute.
+    def initialize(opts = {})
+      @io = opts.fetch(:io) { raise "No IO Object" } 
+      @verbose = opts.fetch(:verbose) { false }      
+      $stdout.sync = true
+      trace 'Booted. Sending Request for file'
+
+      @io.write RequestFile.new
+      begin
+        process_messages
+      rescue => ex
+        trace ex.to_s
+        raise ex
+      end
+    end
+
+    # Run a test file and report the results
+    def run_file(file)
+      trace "Running file: #{file}"
+
+      output = ""
+      if file =~ /_spec.rb$/i
+        output, stats = run_rspec_file(file)
+      elsif file =~ /_testspec.rb$/i
+        output, stats = run_test_spec_file(file)
+      elsif file =~ /.feature$/i
+        output, stats = run_cucumber_file(file)
+      elsif file =~ /.js$/i or file =~ /.json$/i
+        output, stats = run_javascript_file(file)
+      else
+        output, stats = run_test_unit_file(file)
+      end
+
+      output = "." if output == ""
+
+      @io.write Results.new(
+        :output => output,
+        :file   => file,
+        :stats  => stats
+      )
+      return output
+    end
+
+    # Stop running
+    def stop
+      @running = false
+    end
+
+    private
+
+    # The runner will continually read messages and handle them.
+    def process_messages
+      trace "Processing Messages"
+      @running = true
+      while @running
+        begin
+          message = @io.gets
+          if message and !message.class.to_s.index("Worker").nil?
+            trace "Received message from worker"
+            trace "\t#{message.inspect}"
+            message.handle(self)
+          else
+            @io.write Ping.new
+          end
+        rescue IOError => ex
+          trace "Runner lost Worker"
+          @running = false
+        end
+      end
+    end
+
+    # Run all the Test::Unit Suites in a ruby file
+    def run_test_unit_file(file)
+      begin
+        require file
+      rescue LoadError => ex
+        trace "#{file} does not exist [#{ex.to_s}]"
+        return ex.to_s
+      end
+      output = []
+      @result = Test::Unit::TestResult.new
+      @result.add_listener(Test::Unit::TestResult::FAULT) do |value|
+        output << `hostname`.chomp
+        output << value
+      end
+
+      klasses = Runner.find_classes_in_file(file)
+      begin
+        klasses.each{|klass| klass.suite.run(@result){|status, name| ;}}
+      rescue => ex
+        output << `hostname`.chomp
+        output << ex.to_s
+      end
+      stats = {
+        :tests      => @result.run_count,
+        :assertions => @result.assertion_count,
+        :failures   => @result.failure_count,
+        :errors     => @result.error_count,
+      }
+
+      return output.join("\n"), stats
+    end
+
+    # Run all the test/spec file
+    def run_test_spec_file(file)
+      begin
+        require file
+      rescue LoadError => ex
+        trace "#{file} does not exist [#{ex.to_s}]"
+        return ex.to_s
+      end
+      output = []
+      @result = Test::Unit::TestResult.new
+      @result.add_listener(Test::Unit::TestResult::FAULT) do |value|
+        output << `hostname`.chomp
+        output << value
+      end
+
+      klasses = Runner.find_test_spec_classes_in_file(file)
+      begin
+        klasses.each{|klass| klass.suite.run(@result){|status, name| ;}}
+      rescue => ex
+        output << `hostname`.chomp
+        output << ex.to_s
+      end
+
+      stats = {
+        :tests      => @result.run_count,
+        :assertions => @result.assertion_count,
+        :failures   => @result.failure_count,
+        :errors     => @result.error_count,
+      }
+
+      return output.join("\n"), stats
+    end
+
+    # run all the Specs in an RSpec file (NOT IMPLEMENTED)
+    def run_rspec_file(file)
+      # pull in rspec
+      begin
+        require 'rspec'
+        require 'hydra/spec/hydra_formatter'
+        # Ensure we override rspec's at_exit
+        require 'hydra/spec/autorun_override'
+      rescue LoadError => ex
+        return ex.to_s
+      end
+      hydra_output = StringIO.new
+
+      config = [
+        '-f', 'RSpec::Core::Formatters::HydraFormatter',
+        file
+      ]
+
+      RSpec.instance_variable_set(:@world, nil)
+      RSpec::Core::Runner.run(config, hydra_output, hydra_output)
+
+      hydra_output.rewind
+      output = hydra_output.read.chomp
+      output = "" if output.gsub("\n","") =~ /^\.*$/
+
+      return output
+    end
+
+    # run all the scenarios in a cucumber feature file
+    def run_cucumber_file(file)
+
+      files = [file]
+      dev_null = StringIO.new
+      hydra_response = StringIO.new
+
+      unless @step_mother
+        require 'cucumber'
+        require 'hydra/cucumber/formatter'
+        @step_mother = Cucumber::StepMother.new
+        @cuke_configuration = Cucumber::Cli::Configuration.new(dev_null, dev_null)
+        @cuke_configuration.parse!(['features']+files)
+
+        @step_mother.options = @cuke_configuration.options
+        @step_mother.log = @cuke_configuration.log
+        @step_mother.load_code_files(@cuke_configuration.support_to_load)
+        @step_mother.after_configuration(@cuke_configuration)
+        @step_mother.load_code_files(@cuke_configuration.step_defs_to_load)
+      end
+      cuke_formatter = Cucumber::Formatter::Hydra.new(
+        @step_mother, hydra_response, @cuke_configuration.options
+      )
+
+      cuke_runner ||= Cucumber::Ast::TreeWalker.new(
+        @step_mother, [cuke_formatter], @cuke_configuration.options, dev_null
+      )
+      @step_mother.visitor = cuke_runner
+
+      features = @step_mother.load_plain_text_features(files)
+      tag_excess = tag_excess(features, @cuke_configuration.options[:tag_expression].limits)
+      @cuke_configuration.options[:tag_excess] = tag_excess
+
+      cuke_runner.visit_features(features)
+
+      hydra_response.rewind
+      return hydra_response.read
+    end
+
+    def run_javascript_file(file)
+      errors = []
+      require 'v8'
+      V8::Context.new do |context|
+        context.load(File.expand_path(File.join(File.dirname(__FILE__), 'js', 'lint.js')))
+        context['input'] = lambda{
+          File.read(file)
+        }
+        context['reportErrors'] = lambda{|js_errors|
+          js_errors.each do |e|
+            e = V8::To.rb(e)
+            errors << "\n\e[1;31mJSLINT: #{file}\e[0m"
+            errors << "  Error at line #{e['line'].to_i + 1} " + 
+              "character #{e['character'].to_i + 1}: \e[1;33m#{e['reason']}\e[0m"
+            errors << "#{e['evidence']}"
+          end
+        }
+        context.eval %{
+          JSLINT(input(), {
+            sub: true,
+            onevar: true,
+            eqeqeq: true,
+            plusplus: true,
+            bitwise: true,
+            regexp: true,
+            newcap: true,
+            immed: true,
+            strict: true,
+            rhino: true
+          });
+          reportErrors(JSLINT.errors);
+        }
+      end
+
+      if errors.empty?
+        return '.'
+      else
+        return errors.join("\n")
+      end
+    end
+
+    def self.find_test_spec_classes_in_file(f)
+      require f
+      ks = Test::Spec::CONTEXTS.values.map{|k| k.testcase}
+      Test::Spec::CONTEXTS.clear
+      Test::Spec::SHARED_CONTEXTS.clear
+      ks
+    end
+
+    # find all the test unit classes in a given file, so we can run their suites
+    def self.find_classes_in_file(f)
+      code = ""
+      File.open(f) {|buffer| code = buffer.read}
+      matches = code.scan(/class\s+([\S]+)/)
+      klasses = matches.collect do |c|
+        begin
+          if c.first.respond_to? :constantize
+            c.first.constantize
+          else
+            eval(c.first)
+          end
+        rescue NameError
+          # means we could not load [c.first], but thats ok, its just not
+          # one of the classes we want to test
+          nil
+        rescue SyntaxError
+          # see above
+          nil
+        end
+      end
+      return klasses.select{|k| k.respond_to? 'suite'}
+    end
+
+    # Yanked a method from Cucumber
+    def tag_excess(features, limits)
+      limits.map do |tag_name, tag_limit|
+        tag_locations = features.tag_locations(tag_name)
+        if tag_limit && (tag_locations.length > tag_limit)
+          [tag_name, tag_limit, tag_locations]
+        else
+          nil
+        end
+      end.compact
+    end
+  end
+end