nitra 0.9.4 → 0.9.5

data/lib/nitra/worker.rb

@@ -1,128 +1,211 @@
 require 'stringio'
 require 'tempfile'
 
-class Nitra::Worker
-  attr_reader :runner_id, :worker_number, :configuration, :channel
+module Nitra
+  module Workers
+    class Worker
+      class << self
 
-  def initialize(runner_id, worker_number, configuration)
-    @runner_id = runner_id
-    @worker_number = worker_number
-    @configuration = configuration
-  end
+        @@worker_classes = {}
 
-  def fork_and_run
-    client, server = Nitra::Channel.pipe
+        def inherited(klass)
+          @@worker_classes[klass.framework_name] = klass
+        end
 
-    fork do
-      server.close
-      @channel = client
-      run
-    end
+        def worker_classes
+          @@worker_classes
+        end
 
-    client.close
-    server
-  end
+        ##
+        # Return the framework name of this worker
+        #
+        def framework_name
+          self.name.split("::").last.downcase
+        end
+      end
+
+
+      attr_reader :runner_id, :worker_number, :configuration, :channel, :io
+
+      def initialize(runner_id, worker_number, configuration)
+        @runner_id = runner_id
+        @worker_number = worker_number
+        @configuration = configuration
+        @forked_worker_pid = nil
+
+        ENV["TEST_ENV_NUMBER"] = worker_number.to_s
+
+        # Frameworks don't like it when you change the IO between invocations.
+        # So we make one object and flush it after every invocation.
+        @io = StringIO.new
+      end
 
-  protected
-  def run
-    trap("SIGTERM") { Process.kill("SIGKILL", Process.pid) }
-    trap("SIGINT") { Process.kill("SIGKILL", Process.pid) }
-
-    debug "started"
-
-    ENV["TEST_ENV_NUMBER"] = (worker_number + 1).to_s
-
-    # Find the database config for this TEST_ENV_NUMBER and manually initialise a connection.
-    database_config = YAML.load(ERB.new(IO.read("#{Rails.root}/config/database.yml")).result)[ENV["RAILS_ENV"]]
-    ActiveRecord::Base.establish_connection(database_config)
-    Rails.cache.reset if Rails.cache.respond_to?(:reset)
-
-    # RSpec doesn't like it when you change the IO between invocations.  So we make one object and flush it
-    # after every invocation.
-    io = StringIO.new
-
-    # When rspec processes the first spec file, it does initialisation like loading in fixtures into the
-    # database.  If we're forking for each file, we need to initialise first so it doesn't try to initialise
-    # for every single file.
-    if configuration.fork_for_each_file
-      debug "running empty spec to make rspec run its initialisation"
-      file = Tempfile.new("nitra")
-      begin
-        file.write("require 'spec_helper'; describe('nitra preloading') { it('preloads the fixtures') { 1.should == 1 } }\n")
-        file.close
-        output = Nitra::Utils.capture_output do
-          RSpec::Core::CommandLine.new(["-f", "p", file.path]).run(io, io)
+
+      def fork_and_run
+        client, server = Nitra::Channel.pipe
+
+        pid = fork do
+          # This is important. We don't want anything bubbling up to the master that we didn't send there.
+          # We reopen later to get the output from the framework run.
+          $stdout.reopen('/dev/null', 'a')
+          $stderr.reopen('/dev/null', 'a')
+
+          trap("USR1") { interrupt_forked_worker_and_exit }
+
+          server.close
+          @channel = client
+          begin
+            run
+          rescue => e
+            channel.write("command" => "error", "process" => "init framework", "text" => e.message, "worker_number" => worker_number)
+          end
         end
-        channel.write("command" => "stdout", "process" => "init rspec", "text" => output) unless output.empty?
-      ensure
-        file.close unless file.closed?
-        file.unlink
+
+        client.close
+
+        [pid, server]
       end
-      RSpec.reset
-      io.string = ""
-    end
 
-    # Loop until our master tells us we're finished.
-    loop do
-      debug "announcing availability"
-      channel.write("command" => "ready")
+      protected
+      def load_environment
+        raise 'Subclasses must impliment this method.'
+      end
 
-      debug "waiting for next job"
-      data = channel.read
-      if data.nil? || data["command"] == "close"
-        debug "channel closed, exiting"
-        exit
+      def minimal_file
+        raise 'Subclasses must impliment this method.'
+      end
+
+      def run_file(filename, preload = false)
+        raise 'Subclasses must impliment this method.'
       end
 
-      filename = data.fetch("filename").chomp
-      debug "starting to process #{filename}"
+      def clean_up
+        raise 'Subclasses must impliment this method.'
+      end
+
+      def run
+        trap("SIGTERM") do
+          channel.write("command" => "error", "process" => "trap", "text" => 'Received SIGTERM', "worker_number" => worker_number)
+          Process.kill("SIGKILL", Process.pid)
+        end
+        trap("SIGINT") do
+          channel.write("command" => "error", "process" => "trap", "text" => 'Received SIGINT', "worker_number" => worker_number)
+          Process.kill("SIGKILL", Process.pid) 
+        end
+
+        debug "Started, using TEST_ENV_NUMBER #{ENV['TEST_ENV_NUMBER']}"
+        connect_to_database
+        reset_cache
+
+        preload_framework
+
+        # Loop until our runner passes us a message from the master to tells us we're finished.
+        loop do
+          debug "Announcing availability"
+          channel.write("command" => "ready", "framework" => self.class.framework_name, "worker_number" => worker_number)
+          debug "Waiting for next job"
+          data = channel.read
+          if data.nil? || data["command"] == "close"
+            debug "Channel closed, exiting"
+            exit
+          elsif data['command'] == "process"
+            filename = data["filename"].chomp
+            process_file(filename)
+          end
+        end
+      end
 
-      perform_rspec_for_filename = lambda do
+      def preload_framework
+        debug "running empty spec/feature to make framework run its initialisation"
+        file = Tempfile.new("nitra")
         begin
-          result = RSpec::Core::CommandLine.new(["-f", "p", filename]).run(io, io)
-        rescue LoadError
-          io << "\nCould not load file #{filename}\n\n"
-          result = 1
+          load_environment
+          file.write(minimal_file)
+          file.close
+
+          output = Nitra::Utils.capture_output do
+            run_file(file.path, true)
+          end
+
+          channel.write("command" => "stdout", "process" => "init framework", "text" => output, "worker_number" => worker_number) unless output.empty?
+        ensure
+          file.close unless file.closed?
+          file.unlink
+          io.string = ""
         end
+        clean_up
+      end
 
-        channel.write("command" => "result", "filename" => filename, "return_code" => result.to_i, "text" => io.string)
+    def connect_to_database
+      if defined?(Rails)
+        Nitra::RailsTooling.connect_to_database
+        debug("Connected to database #{ActiveRecord::Base.connection.current_database}")
       end
+    end
+
+    def reset_cache
+      Nitra::RailsTooling.reset_cache if defined?(Rails)
+    end
+
+      ##
+      # Process the file, forking before hand.
+      #
+      # There's two sets of data we're interested in, the output from the test framework, and any other output.
+      # 1) We capture the framework's output in the @io object and send that up to the runner in a results message.
+      # This happens in the run_x_file methods.
+      # 2) Anything else we capture off the stdout/stderr using the pipe and fire off in the stdout message.
+      #
+      def process_file(filename)
+        debug "Starting to process #{filename}"
+        start_time = Time.now
 
-      if configuration.fork_for_each_file
         rd, wr = IO.pipe
-        pid = fork do
-          rd.close
+        @forked_worker_pid = fork do
+          trap('USR1') { exit! }  # at_exit hooks will be run in the parent.
           $stdout.reopen(wr)
           $stderr.reopen(wr)
-          perform_rspec_for_filename.call
+          rd.close
+          $0 = filename
+          run_file(filename)
+          wr.close
+          exit!  # at_exit hooks will be run in the parent.
         end
         wr.close
-        stdout_buffer = ""
+        output = ""
         loop do
           IO.select([rd])
           text = rd.read
           break if text.nil? || text.length.zero?
-          stdout_buffer << text
+          output.concat text
         end
         rd.close
-        Process.wait(pid) if pid
-      else
-        stdout_buffer = Nitra::Utils.capture_output do
-          perform_rspec_for_filename.call
-        end
-        io.string = ""
-        RSpec.reset
+        Process.wait(@forked_worker_pid) if @forked_worker_pid
+
+        @forked_worker_pid = nil
+
+        end_time = Time.now
+        channel.write("command" => "stdout", "process" => "test framework", "filename" => filename, "text" => output, "worker_number" => worker_number) unless output.empty?
+        debug "#{filename} processed in #{'%0.2f' % (end_time - start_time)}s"
       end
-      channel.write("command" => "stdout", "process" => "rspec", "filename" => filename, "text" => stdout_buffer) unless stdout_buffer.empty?
 
-      debug "#{filename} processed"
-    end
-  end
 
-  def debug(*text)
-    channel.write(
-      "command" => "debug",
-      "text" => "worker #{runner_id}.#{worker_number}: #{text.join}"
-    ) if configuration.debug
+      ##
+      # Interrupts the forked worker cleanly and exits
+      #
+      def interrupt_forked_worker_and_exit
+        Process.kill('USR1', @forked_worker_pid) if @forked_worker_pid
+        Process.waitall
+        exit
+      end
+
+      ##
+      # Sends debug data up to the runner.
+      #
+      def debug(*text)
+        if configuration.debug
+          channel.write("command" => "debug", "text" => "worker #{runner_id}.#{worker_number}: #{text.join}", "worker_number" => worker_number)
+        end
+      end
+    end
   end
 end

data/lib/nitra/workers/cucumber.rb

@@ -0,0 +1,62 @@
+module Nitra::Workers
+  class Cucumber < Worker
+    def self.files
+      Dir["features/**/*.feature"].sort_by {|f| File.size(f)}.reverse
+    end
+
+    def self.filename_match?(filename)
+      filename =~ /\.feature/
+    end
+
+    def initialize(runner_id, worker_number, configuration)
+      super(runner_id, worker_number, configuration)
+    end
+
+    def load_environment
+      require 'cucumber'
+      require 'nitra/ext/cucumber'
+    end
+
+    def minimal_file
+      <<-EOS
+      Feature: cucumber preloading
+        Scenario: a fake scenario
+          Given every step is unimplemented
+          When we run this file
+          Then Cucumber will load it's environment
+      EOS
+    end
+
+    ##
+    # Run a Cucumber file and write the results back to the runner.
+    #
+    # Doesn't write back to the runner if we mark the run as preloading.
+    #
+    def run_file(filename, preloading = false)
+      @cuke_runtime ||= ::Cucumber::ResetableRuntime.new  # This runtime gets reused, this is important as it's the part that loads the steps...
+      begin
+        result = 1
+        cuke_config = ::Cucumber::Cli::Configuration.new(io, io)
+        cuke_config.parse!(["--no-color", "--require", "features", filename])
+        @cuke_runtime.configure(cuke_config)
+        @cuke_runtime.run!
+        result = 0 unless @cuke_runtime.results.failure?
+      rescue LoadError => e
+        io << "\nCould not load file #{filename}: #{e.message}\n\n"
+      rescue Exception => e
+        io << "Exception when running #{filename}: #{e.message}"
+        io << e.backtrace[0..7].join("\n")
+      end
+
+      if preloading
+        puts(io.string)
+      else
+        channel.write("command" => "result", "filename" => filename, "return_code" => result.to_i, "text" => io.string, "worker_number" => worker_number)
+      end
+    end
+
+    def clean_up
+      @cuke_runtime.reset
+    end
+  end
+end

data/lib/nitra/workers/rspec.rb

@@ -0,0 +1,65 @@
+module Nitra::Workers
+  class Rspec < Worker
+    def self.files
+      Dir["spec/**/*_spec.rb"].sort_by {|f| File.size(f)}.reverse
+    end
+
+    def self.filename_match?(filename)
+      filename =~ /_spec\.rb/
+    end
+
+    def initialize(runner_id, worker_number, configuration)
+      super(runner_id, worker_number, configuration)
+    end
+
+    def load_environment
+      require 'rspec'
+      RSpec::Core::Runner.disable_autorun!
+    end
+
+    def minimal_file
+      <<-EOS
+      require 'spec_helper'
+      describe('nitra preloading') do
+        it('preloads the fixtures') do
+          expect(1).to eq(1)
+        end
+      end
+      EOS
+    end
+
+    ##
+    # Run an rspec file and write the results back to the runner.
+    #
+    # Doesn't write back to the runner if we mark the run as preloading.
+    #
+    def run_file(filename, preloading = false)
+      begin
+        result = RSpec::Core::CommandLine.new(["-f", "p", filename]).run(io, io)
+      rescue LoadError => e
+        io << "\nCould not load file #{filename}: #{e.message}\n\n"
+        result = 1
+      rescue Exception => e
+        io << "Exception when running #{filename}: #{e.message}"
+        io << e.backtrace[0..7].join("\n")
+        result = 1
+      end
+
+      if preloading
+        puts io.string
+      else
+        channel.write("command" => "result", "filename" => filename, "return_code" => result.to_i, "text" => io.string, "worker_number" => worker_number)
+      end
+    end
+
+    def clean_up
+      # Rspec.reset in 2.6 didn't destroy your rspec_rails fixture loading, we can't use it anymore for it's intended purpose.
+      # This means our world object will be slightly polluted by the preload_framework code, but that's a small price to pay
+      # to upgrade.
+      #
+      # RSpec.reset
+      #
+      RSpec.instance_variable_set(:@world, nil)
+    end
+  end
+end

data/lib/nitra.rb

@@ -2,12 +2,16 @@ module Nitra
 end
 
 require 'nitra/channel'
-require 'nitra/client'
 require 'nitra/command_line'
 require 'nitra/configuration'
 require 'nitra/master'
+require 'nitra/formatter'
 require 'nitra/progress'
 require 'nitra/runner'
+require 'nitra/tasks'
 require 'nitra/slave'
 require 'nitra/utils'
 require 'nitra/worker'
+require 'nitra/workers/cucumber'
+require 'nitra/workers/rspec'
+require 'nitra/rails_tooling'

data/spec/nitra/channel_spec.rb

@@ -0,0 +1,44 @@
+gem 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require_relative '../../lib/nitra/channel'
+
+describe Nitra::Channel do
+  describe ".pipe" do
+    it "creates a pipe pair" do
+      server, client = Nitra::Channel.pipe
+      server.must_be_instance_of Nitra::Channel
+      client.must_be_instance_of Nitra::Channel
+    end
+  end
+
+  describe "#close" do
+    it "closes channels" do
+      server, client = Nitra::Channel.pipe
+      server.close
+      server.rd.must_be :closed?
+      server.wr.must_be :closed?
+    end
+  end
+
+  describe "#write" do
+    it "writes a NITRA encoded yaml message" do
+      server, client = Nitra::Channel.pipe
+      server.write(['encode all the things'])
+      client.read.must_equal ['encode all the things']
+    end
+  end
+
+  describe "#read" do
+    it "reads NITRA encoded yaml messages" do
+      server, client = Nitra::Channel.pipe
+      client.write(['encode all the things'])
+      server.read.must_equal ['encode all the things']
+    end
+    it "rejects bad messages" do
+      server, client = Nitra::Channel.pipe
+      client.wr.write("not a nitra packet\n")
+      proc {server.read}.must_raise Nitra::Channel::ProtocolInvalidError
+    end
+  end
+end

data/spec/nitra/command_line_spec.rb

@@ -0,0 +1,133 @@
+gem 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require_relative '../../lib/nitra/command_line'
+
+describe Nitra::CommandLine do
+
+  let(:config){ m = MiniTest::Mock.new; m.expect(:set_default_framework, []); m}
+
+  describe "option parsing" do
+    describe "-c" do
+      it "sets process count" do
+        config.expect(:set_process_count, nil, [2])
+        Nitra::CommandLine.new(config, ['-c','2'])
+        config.verify
+      end
+    end
+
+    describe "--cucumber" do
+      it "adds cucumber to framework" do
+        config.expect(:add_framework, nil, ['cucumber'])
+        Nitra::CommandLine.new(config, ['--cucumber'])
+        config.verify
+      end
+    end
+
+    describe "--debug" do
+      it "adds debug flag" do
+        config.expect(:debug=, nil, [true])
+        Nitra::CommandLine.new(config, ['--debug'])
+        config.verify
+      end
+    end
+
+    describe "-p" do
+      it "adds print failure flag" do
+        config.expect(:print_failures=, nil, [true])
+        Nitra::CommandLine.new(config, ['-p'])
+        config.verify
+      end
+    end
+
+    describe "-q" do
+      it "adds quiet flag" do
+        config.expect(:quiet=, nil, [true])
+        Nitra::CommandLine.new(config, ['-q'])
+        config.verify
+      end
+    end
+
+    describe "-e" do
+      it "sets the rails environment" do
+        config.expect(:environment=, nil, ["test"])
+        Nitra::CommandLine.new(config, ["-e", "test"])
+        config.verify
+      end
+    end
+
+    describe "--rake-after-runner" do
+      it "adds rake tasks to run after runner finishes" do
+        config.expect(:add_rake_task, nil, [:after_runner, ['list:of','rake:tasks']])
+        Nitra::CommandLine.new(config, ['--rake-after-runner', 'list:of,rake:tasks'])
+        config.verify
+      end
+    end
+
+    describe "--rake-before-runner" do
+      it "adds rake tasks to run before runner starts" do
+        config.expect(:add_rake_task, nil, [:before_runner, ['list:of','rake:tasks']])
+        Nitra::CommandLine.new(config, ['--rake-before-runner', 'list:of,rake:tasks'])
+        config.verify
+      end
+    end
+
+    describe "--rake-before-worker" do
+      it "adds rake tasks to run before worker starts" do
+        config.expect(:add_rake_task, nil, [:before_worker, ['list:of','rake:tasks']])
+        Nitra::CommandLine.new(config, ['--rake-before-worker', 'list:of,rake:tasks'])
+        config.verify
+      end
+    end
+
+    describe "-r" do
+      it "adds the db:reset rake task to run before worker starts" do
+        config.expect(:add_rake_task, nil, [:before_worker, ['db:reset']])
+        Nitra::CommandLine.new(config, ['-r'])
+        config.verify
+      end
+    end
+
+    describe "--reset" do
+      it "adds the db:reset rake task to run before worker starts" do
+        config.expect(:add_rake_task, nil, [:before_worker, ['db:reset']])
+        Nitra::CommandLine.new(config, ['--reset'])
+        config.verify
+      end
+    end
+
+    describe "--rspec" do
+      it "adds rspec to framework" do
+        config.expect(:add_framework, nil, ['rspec'])
+        Nitra::CommandLine.new(config, ['--rspec'])
+        config.verify
+      end
+    end
+
+    describe "--slave-mode" do
+      it "turns on slave mode" do
+        config.expect(:slave_mode=, nil, [true])
+        Nitra::CommandLine.new(config, ['--slave-mode'])
+        config.verify
+      end
+    end
+
+    describe "--slave" do
+      it "adds a command that will be run later as a slave" do
+        config.expect(:add_slave, nil, ['the command to run'])
+        Nitra::CommandLine.new(config, ['--slave', 'the command to run'])
+        config.verify
+      end
+    end
+  end
+
+  describe "file lists" do
+    it "parses out options and leavs only files in list" do
+      argv = ['--slave','the slave command','this_test_file_spec.rb']
+      config.expect(:add_slave, nil, ['the slave command'])
+      Nitra::CommandLine.new(config, argv)
+      config.verify
+      argv.must_equal ['this_test_file_spec.rb']
+    end
+  end
+end

data/spec/nitra/configuration_spec.rb

@@ -0,0 +1,60 @@
+gem 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require_relative '../../lib/nitra/configuration'
+
+describe Nitra::Configuration do
+  let(:config){ Nitra::Configuration.new }
+  it "has default values" do
+    config.slaves.must_equal []
+    config.frameworks.must_equal []
+    config.rake_tasks.must_equal Hash.new;
+    config.process_count.must_equal Nitra::Utils.processor_count
+  end
+
+  describe "#add_framework" do
+    it "adds a framework to frameworks" do
+      config.add_framework("cucumber")
+      config.add_framework("rspec")
+      config.frameworks.must_equal ["cucumber", "rspec"]
+    end
+  end
+
+  describe "#add_rake_task" do
+    it "adds a rake task to the rake task hash" do
+      config.add_rake_task(:task_name, ['list','of','tasks'])
+      config.rake_tasks.must_equal({:task_name => ['list','of','tasks']})
+    end
+  end
+
+  describe "#add_slave" do
+    it "adds a slave command to the slave array" do
+      command = 'command to run to get a nitra slave'
+      config.add_slave(command)
+      config.slaves[0].must_equal({:command => command, :cpus => nil})
+    end
+  end
+
+  describe "#set_default_framework" do
+    it "sets the default framework to the first one in the list" do
+      config.add_framework 'rspec'
+      config.add_framework 'cucumber'
+      config.set_default_framework
+      config.framework.must_equal 'rspec'
+    end
+
+    it "does nothing when there's no frameworks" do
+      config.set_default_framework
+      config.framework.must_be_nil
+    end
+  end
+
+  # We want slaves to inherit all config except for process count.
+  # This needs refactoring to not be so frickin retardedk.
+  it "does interesting things with slave process configs" do
+    config.process_count.must_equal Nitra::Utils.processor_count
+    config.slaves << {}
+    config.set_process_count 1000
+    config.slaves.first[:cpus].must_equal 1000
+  end
+end