zeus-justinf 0.13.5

data/lib/zeus/m/test_method.rb

@@ -0,0 +1,39 @@
+module Zeus
+  module M
+    ### Simple data structure for what a test method contains.
+    #
+    # Too lazy to make a class for this when it's really just a bag of data
+    # without any behavior.
+    #
+    # Includes the name of this method, what line on the file it begins on,
+    # and where it ends.
+    class TestMethod < Struct.new(:name, :start_line, :end_line)
+      # Set up a new test method for this test suite class
+      def self.create(suite_class, test_method, find_locations = true)
+        # Hopefully it's been defined as an instance method, so we'll need to
+        # look up the ruby Method instance for it
+        method = suite_class.instance_method(test_method)
+
+        if find_locations
+          # Ruby can find the starting line for us, so pull that out of the array
+          start_line = method.source_location.last
+
+          # Ruby can't find the end line however, and I'm too lazy to write
+          # a parser. Instead, `method_source` adds `Method#source` so we can
+          # deduce this ourselves.
+          #
+          # The end line should be the number of line breaks in the method source,
+          # added to the starting line and subtracted by one.
+          end_line = method.source.split("\n").size + start_line - 1
+        end
+
+        # Shove the given attributes into a new databag
+        new(test_method, start_line, end_line)
+      end
+
+      def escaped_name
+        Regexp.escape(name)
+      end
+    end
+  end
+end

data/lib/zeus/plan.rb

@@ -0,0 +1,6 @@
+module Zeus
+  class Plan
+    def after_fork ; end
+  end
+end
+

data/lib/zeus/rails.rb

@@ -0,0 +1,256 @@
+def find_rails_path(root_path)
+  paths = %w(spec/dummy test/dummy .)
+  paths.find { |path| File.exists?(File.expand_path(path, root_path)) }
+end
+
+ROOT_PATH = File.expand_path(Dir.pwd)
+RAILS_PATH = find_rails_path(ROOT_PATH)
+ENV_PATH  = File.expand_path('config/environment',  RAILS_PATH)
+BOOT_PATH = File.expand_path('config/boot',  RAILS_PATH)
+APP_PATH  = File.expand_path('config/application',  RAILS_PATH) unless defined? APP_PATH
+
+require 'zeus'
+
+def gem_is_bundled?(gem)
+  gemfile_lock_contents = File.read(ROOT_PATH + "/Gemfile.lock")
+  gemfile_lock_contents.scan(/^\s*#{gem} \(([^=~><]+?)\)/).flatten.first
+end
+
+if version = gem_is_bundled?('method_source')
+  gem 'method_source', version
+end
+
+require 'zeus/m'
+
+module Zeus
+  class Rails < Plan
+    def after_fork
+      reconnect_activerecord
+      restart_girl_friday
+      reconnect_redis
+    end
+
+    def _monkeypatch_rake
+      if version = gem_is_bundled?('rake')
+        gem 'rake', version
+      end
+      require 'rake/testtask'
+      Rake::TestTask.class_eval {
+
+        # Create the tasks defined by this task lib.
+        def define
+          desc "Run tests" + (@name==:test ? "" : " for #{@name}")
+          task @name do
+            # ruby "#{ruby_opts_string} #{run_code} #{file_list_string} #{option_list}"
+            rails_env = ENV['RAILS_ENV']
+            rubyopt = ENV['RUBYOPT']
+            ENV['RAILS_ENV'] = nil
+            ENV['RUBYOPT'] = nil # bundler sets this to require bundler :|
+            puts "zeus test #{file_list_string}"
+            ret = system "zeus test #{file_list_string}"
+            ENV['RAILS_ENV'] = rails_env
+            ENV['RUBYOPT'] = rubyopt
+            ret
+          end
+          self
+        end
+
+        alias_method :_original_define, :define
+
+        def self.inherited(klass)
+          return unless klass.name == "TestTaskWithoutDescription"
+          klass.class_eval {
+            def self.method_added(sym)
+              class_eval do
+                if !@rails_hack_reversed
+                  @rails_hack_reversed = true
+                  alias_method :define, :_original_define
+                  def desc(*)
+                  end
+                end
+              end
+            end
+          }
+        end
+      }
+    end
+
+    def boot
+      _monkeypatch_rake
+      $LOAD_PATH.unshift "./lib"
+
+      require BOOT_PATH
+      # config/application.rb normally requires 'rails/all'.
+      # Some 'alternative' ORMs such as Mongoid give instructions to switch this require
+      # out for a list of railties, not including ActiveRecord.
+      # We grep config/application.rb for all requires of rails/all or railties, and require them.
+      rails_components = File.read(APP_PATH + ".rb").
+        scan(/^\s*require\s*['"](.*railtie.*|rails\/all)['"]/).flatten
+
+      rails_components = ["rails/all"] if rails_components == []
+      rails_components.each do |component|
+        require component
+      end
+    end
+
+    def default_bundle
+      Bundler.require(:default)
+      Zeus::LoadTracking.add_feature('./Gemfile.lock')
+    end
+
+    def development_environment
+      Bundler.require(:development)
+      ::Rails.env = ENV['RAILS_ENV'] = "development"
+      require APP_PATH
+      ::Rails.application.require_environment!
+    end
+
+    def prerake
+      require 'rake'
+    end
+
+    def rake
+      Rake.application.run
+    end
+
+    def generate
+      load_rails_generators
+      require 'rails/commands/generate'
+    end
+
+    def destroy
+      load_rails_generators
+      require 'rails/commands/destroy'
+    end
+
+    def runner
+      require 'rails/commands/runner'
+    end
+
+    def console
+      if defined?(Pry) && IRB == Pry
+        require "pry"
+        Pry.start
+      else
+        require 'rails/commands/console'
+        ::Rails::Console.start(::Rails.application)
+      end
+    end
+
+    def dbconsole
+      require 'rails/commands/dbconsole'
+
+      meth = ::Rails::DBConsole.method(:start)
+
+      # `Rails::DBConsole.start` has been changed to load faster in
+      # https://github.com/rails/rails/commit/346bb018499cde6699fcce6c68dd7e9be45c75e1
+      #
+      # This will work with both versions.
+      if meth.arity.zero?
+        ::Rails::DBConsole.start
+      else
+        ::Rails::DBConsole.start(::Rails.application)
+      end
+    end
+
+    def server
+      require 'rails/commands/server'
+      server = ::Rails::Server.new
+      Dir.chdir(::Rails.application.root)
+      server.start
+    end
+
+    def test_environment
+      Bundler.require(:test)
+
+      ::Rails.env = ENV['RAILS_ENV'] = 'test'
+      require APP_PATH
+
+      $rails_rake_task = 'yup' # lie to skip eager loading
+      ::Rails.application.require_environment!
+      $rails_rake_task = nil
+
+      $LOAD_PATH.unshift ".", "./lib", "./test", "./spec"
+    end
+
+    def test_helper
+      # don't let minitest setup another exit hook
+      begin
+        require 'minitest/unit'
+        MiniTest::Unit.class_variable_set("@@installed_at_exit", true)
+      rescue LoadError
+        # noop
+      end
+
+      if ENV['RAILS_TEST_HELPER']
+        require ENV['RAILS_TEST_HELPER']
+      else
+        if File.exists?(ROOT_PATH + "/spec/spec_helper.rb")
+          require 'spec_helper'
+        elsif File.exists?(ROOT_PATH + "/test/minitest_helper.rb")
+          require 'minitest_helper'
+        else
+          require 'test_helper'
+        end
+      end
+    end
+
+    def test(argv=ARGV)
+      if spec_file?(argv) && defined?(RSpec)
+        # disable autorun in case the user left it in spec_helper.rb
+        RSpec::Core::Runner.disable_autorun!
+        exit RSpec::Core::Runner.run(argv)
+      else
+        Zeus::M.run(argv)
+      end
+    end
+
+    private
+
+    SPEC_DIR_REGEXP = %r"(^|/)spec"
+    SPEC_FILE_REGEXP = /.+_spec\.rb$/
+
+    def spec_file? argv
+      argv.any? do |arg|
+        arg.match(Regexp.union(SPEC_DIR_REGEXP, SPEC_FILE_REGEXP))
+      end
+    end
+
+    def restart_girl_friday
+      return unless defined?(GirlFriday::WorkQueue)
+      # The Actor is run in a thread, and threads don't persist post-fork.
+      # We just need to restart each one in the newly-forked process.
+      ObjectSpace.each_object(GirlFriday::WorkQueue) do |obj|
+        obj.send(:start)
+      end
+    end
+
+    def reconnect_activerecord
+      return unless defined?(ActiveRecord::Base)
+      begin
+        ActiveRecord::Base.clear_all_connections!
+        ActiveRecord::Base.establish_connection
+        if ActiveRecord::Base.respond_to?(:shared_connection)
+          ActiveRecord::Base.shared_connection = ActiveRecord::Base.retrieve_connection
+        end
+      rescue ActiveRecord::AdapterNotSpecified
+      end
+    end
+
+    def reconnect_redis
+      return unless defined?(Redis::Client)
+      ObjectSpace.each_object(Redis::Client) do |client|
+        client.connect rescue nil
+      end
+    end
+
+    def load_rails_generators
+      require 'rails/generators'
+      ::Rails.application.load_generators
+    rescue LoadError # Rails 3.0 doesn't require this block to be run, but 3.2+ does
+    end
+
+  end
+end
+
+Zeus.plan ||= Zeus::Rails.new

data/lib/zeus/version.rb

@@ -0,0 +1,3 @@
+module Zeus
+  VERSION = '0.13.5'
+end

data/spec/fake_mini_test.rb

@@ -0,0 +1,42 @@
+module MiniTest
+  module Unit
+    class TestCase
+    end
+  end
+end
+
+def stub_mini_test_methods
+  MiniTest::Unit::TestCase.stub!(:test_suites).and_return [fake_suite]
+  MiniTest::Unit.stub!(:runner).and_return fake_runner
+end
+
+def fake_runner
+ @runner ||= stub("Runner", :run => 0)
+end
+
+def fake_suite
+  @suite ||= stub("TestSuite",
+                  :test_methods => [fake_test_method],
+                  :instance_method => fake_instance_method)
+end
+
+def fake_suite_with_special_characters
+  @suite ||= stub("TestSuite",
+                  :test_methods => [fake_special_characters_test_method],
+                  :instance_method => fake_instance_method(fake_special_characters_test_method))
+end
+
+def fake_test_method
+  "test_method"
+end
+
+def fake_special_characters_test_method
+  "test_my_test_method?"
+end
+
+def fake_instance_method(name=fake_test_method)
+  @instance_method ||=  stub("InstanceMethod",
+                             :source_location => ["path/to/file.rb", 2],
+                             :source => "def #{name} \n assert true \n end")
+end
+

data/spec/m_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'fake_mini_test'
+
+module Zeus::M
+  describe Runner do
+
+    context "given a test with a question mark" do
+      before do
+        MiniTest::Unit::TestCase.stub!(:test_suites).and_return [fake_suite_with_special_characters]
+        MiniTest::Unit.stub!(:runner).and_return fake_runner
+      end
+
+      it "escapes the question mark when using line number" do
+        argv = ["path/to/file.rb:2"]
+
+        fake_runner.should_receive(:run).with(["-n", "/(test_my_test_method\\?)/"])
+
+        lambda { Runner.new(argv).run }.should exit_with_code(0)
+      end
+
+      it "escapes the question mark from explicit names" do
+        argv = ["path/to/file.rb", "--name", fake_special_characters_test_method]
+
+        fake_runner.should_receive(:run).with(["-n", "test_my_test_method\\?"])
+
+        lambda { Runner.new(argv).run }.should exit_with_code(0)
+      end
+    end
+  end
+
+  describe Runner do
+    before do
+      stub_mini_test_methods
+    end
+
+    context "no option is given" do
+      it "runs the test without giving any option" do
+        argv = ["path/to/file.rb"]
+
+        fake_runner.should_receive(:run).with([])
+
+        lambda { Runner.new(argv).run }.should exit_with_code(0)
+      end
+    end
+
+    context "given a line number" do
+      it "aborts if no test is found" do
+        argv = ["path/to/file.rb:100"]
+
+        STDERR.should_receive(:write).with(/No tests found on line 100/)
+        fake_runner.should_not_receive :run
+
+        lambda { Runner.new(argv).run }.should_not exit_with_code(0)
+      end
+
+      it "runs the test if the correct line number is given" do
+        argv = ["path/to/file.rb:2"]
+
+        fake_runner.should_receive(:run).with(["-n", "/(#{fake_test_method})/"])
+
+        lambda { Runner.new(argv).run }.should exit_with_code(0)
+      end
+    end
+
+    context "specifying test name" do
+      it "runs the specified tests when using a pattern in --name option" do
+        argv = ["path/to/file.rb", "--name", "/#{fake_test_method}/"]
+
+        fake_runner.should_receive(:run).with(["-n", "/#{fake_test_method}/"])
+
+        lambda { Runner.new(argv).run }.should exit_with_code(0)
+      end
+
+      it "runs the specified tests when using a pattern in -n option" do
+        argv = ["path/to/file.rb", "-n", "/method/"]
+
+        fake_runner.should_receive(:run).with(["-n", "/method/"])
+
+        lambda { Runner.new(argv).run }.should exit_with_code(0)
+      end
+
+      it "aborts if no test matches the given pattern" do
+        argv = ["path/to/file.rb", "-n", "/garbage/"]
+
+        STDERR.should_receive(:write).with(%r{No test name matches \'/garbage/\'})
+        fake_runner.should_not_receive :run
+
+        lambda { Runner.new(argv).run }.should_not exit_with_code(0)
+      end
+
+      it "runs the specified tests when using a name (no pattern)" do
+        argv = ["path/to/file.rb", "-n", "#{fake_test_method}"]
+
+        fake_runner.should_receive(:run).with(["-n", fake_test_method])
+
+        lambda { Runner.new(argv).run }.should exit_with_code(0)
+      end
+
+      it "aborts if no test matches the given test name" do
+        argv = ["path/to/file.rb", "-n", "method"]
+
+        STDERR.should_receive(:write).with(%r{No test name matches \'method\'})
+        fake_runner.should_not_receive :run
+
+        lambda { Runner.new(argv).run }.should_not exit_with_code(0)
+      end
+    end
+  end
+
+end