railsapp_factory 0.0.1

data/lib/railsapp_factory/helper_methods.rb

@@ -0,0 +1,118 @@
+require 'logger'
+require 'railsapp_factory/string_inquirer'
+
+class RailsappFactory
+  module HelperMethods
+
+    attr_writer :logger
+
+    attr_accessor :gem_source, :db, :timeout, :logger
+
+    def override_ENV
+      @override_ENV ||= {}
+    end
+
+    def logger
+      @logger ||= Logger.new(STDERR)
+    end
+
+    def uri(path = '', query_args = {})
+      URI(self.url(path, query_args))
+    end
+
+    def url(path = '', query_args = {})
+      "http://127.0.0.1:#{self.port}/" + path.to_s.sub(/^\//, '') + self.class.encode_query(query_args)
+    end
+
+    def env=(value)
+      self.override_ENV['RAILS_ENV'] = value
+      self.override_ENV['RACK_ENV'] = value
+      self.env
+    end
+
+    def env
+      rails_env = self.override_ENV['RAILS_ENV'] || self.override_ENV['RACK_ENV'] || 'test'
+      @_env = nil unless @_env.to_s == rails_env
+      @_env ||= RailsappFactory::StringInquirer.new(rails_env)
+    end
+
+    #def rubies(rails_v = @version)
+    #  self.class.rubies(rails_v)
+    #end
+
+    def alive?
+      if @pid
+        begin
+          Process.kill(0, @pid)
+          self.logger.debug "Process #{@pid} is alive"
+          true
+        rescue Errno::EPERM
+          self.logger.warning "Process #{@pid} has changed uid - we will not be able to signal it to finish"
+          true # changed uid
+        rescue Errno::ESRCH
+          self.logger.debug "Process #{@pid} not found"
+          false # NOT running
+        rescue Exception => ex
+          self.logger.warning "Process #{@pid} in unknown state: #{ex}"
+          nil # Unable to determine status
+        end
+      end
+    end
+
+    private
+
+    # get backtrace except for this method
+
+    def get_backtrace
+      raise 'get backtrace'
+    rescue => ex
+      trace = ex.backtrace
+      trace.shift
+      trace
+    end
+
+    def see_log(file)
+      self.logger.debug? ? '' : " - see #{file}"
+    end
+
+    def append_log(file)
+      self.logger.debug? ? '' : " >> #{file} 2>&1"
+    end
+
+    def bundle_command
+      "#{self.class.ruby_command_prefix(self.using)} bundle"
+    end
+
+    def ruby_command(bundled = true)
+      "#{self.class.ruby_command_prefix(self.using)} #{bundled ? 'bundle exec' : ''} ruby"
+    end
+
+    def find_command(script_name, rails_arg)
+      result = Dir.chdir(root) do
+        if File.exists?("script/#{script_name}")
+          "#{bundle_command} exec script/#{script_name}"
+        elsif File.exists?('script/rails')
+          "#{bundle_command} exec script/rails #{rails_arg}"
+        else
+          "#{ruby_command(false)} .bundle/bin/rails #{rails_arg}"
+        end
+      end
+      self.logger.info("find_command(#{script_name.inspect}, #{rails_arg.inspect}) returned #{result.inspect}")
+      result
+    end
+
+    def generate_command
+      find_command('generate', 'generate')
+    end
+
+    def runner_command
+      find_command('runner', 'runner')
+    end
+
+    def server_command
+      find_command('server', 'server')
+    end
+
+  end
+
+end

data/lib/railsapp_factory/run_in_app_methods.rb

@@ -0,0 +1,157 @@
+require 'json'
+require 'yaml'
+require 'tempfile'
+require 'fileutils'
+
+class RailsappFactory
+  module RunInAppMethods
+
+    def using
+      @using ||= nil
+    end
+
+    def use(ruby_v)
+      if block_given?
+        begin
+          orig_using = self.using
+          @using = ruby_v.to_s
+          result = yield
+        ensure
+          @using = orig_using
+        end
+      else
+        result = @using = ruby_v.to_s
+      end
+      result
+    end
+
+    def in_app(in_directory = built? ? root : base_dir)
+      Dir.chdir(in_directory) do
+        setup_env do
+          if @timeout > 0
+            Timeout.timeout(@timeout) do
+              yield
+            end
+          else
+            yield
+          end
+        end
+      end
+    end
+
+# returns value from ruby command run in ruby, serialized via to_json to keep to simple values
+    def ruby_eval(expression, serialize_with = :json, evaluate_with = :ruby)
+      result = nil
+
+      evaluate_with = :runner if RUBY_VERSION =~ /^1\.8/ and serialize_with == :json
+      script_dir = File.join(base_dir, 'scripts')
+      FileUtils.mkdir_p script_dir
+      script_file = Tempfile.new(["#{evaluate_with}_", '.rb'], script_dir)
+      expression_file = script_file.path
+      output_file = "#{expression_file.sub(/\.rb$/, '')}.output"
+      script_contents = <<-EOF
+      require '#{serialize_with}'; value = begin; def value_of_expression; #{expression}
+        end
+        { 'value' => value_of_expression }
+      rescue Exception => ex
+        { 'exception' => ex.class.to_s, 'message' => ex.message, 'backtrace' => ex.backtrace }
+      end
+      File.open('#{output_file}', 'w') do |_script_output|
+         _script_output.puts value.to_#{serialize_with}
+      end
+      EOF
+      script_file.puts script_contents
+      script_file.close
+      self.logger.debug "#{evaluate_with}_eval running script #{expression_file} #{see_log('eval.log')}"
+      command = if evaluate_with == :ruby
+                  ruby_command(bundled?)
+                elsif evaluate_with == :runner
+                  runner_command
+                else
+                  raise ArgumentError.new('invalid evaluate_with argument')
+                end
+      system_in_app "sh -xc '#{command} #{expression_file}' #{append_log('eval.log')}"
+      self.logger.info("#{evaluate_with}_eval of #{expression} returned exit status of #{$?} - #{expression_file}")
+      if File.size?(output_file)
+        res = if serialize_with == :json
+                JSON.parse(File.read(output_file))
+              else
+                YAML.load_file(output_file)
+              end
+        FileUtils.rm_f output_file
+        FileUtils.rm_f expression_file
+        if res.include? 'value'
+          result = res['value']
+        elsif res.include? 'exception'
+          result = begin
+            Object.const_get(res['exception']).new(res['message'] || 'Unknown')
+          rescue
+            RuntimeError.new("#{res['exception']}: #{res['message']}")
+          end
+          result.set_backtrace(res['backtrace'] + get_backtrace) if res['backtrace']
+          raise result
+        end
+      else
+        result = ArgumentError.new("unknown error, possibly a syntax error, (missing #{output_file}) #{see_log('eval.log')} - #{expression_file} contains:\n#{command}")
+        raise result
+      end
+      result
+    end
+
+# returns value from expression passed to runner, serialized via to_json to keep to simple values
+    def rails_eval(expression, serialize_with = :json)
+      ruby_eval(expression, serialize_with, :runner)
+    end
+
+    def shell_eval(*args)
+      arg = prepend_ruby_version_command_to_arg(args)
+      in_app { IO.popen(arg, 'r').read }
+    end
+
+    def prepend_ruby_version_command_to_arg(args)
+      arg = args.count == 1 ? args.first : args
+      command_prefix = RailsappFactory.ruby_command_prefix(@using)
+      if arg.kind_of?(Array)
+        arg = command_prefix.split(' ') + arg
+      else
+        arg = "#{command_prefix} #{arg}"
+      end
+      self.logger.info("prepend_ruby_version_command_to_arg returned: #{arg.inspect}")
+      arg
+    end
+
+    def system_in_app(*args)
+      arg = prepend_ruby_version_command_to_arg(args)
+      in_app { Kernel.system(arg) }
+    end
+
+    private
+
+    def setup_env
+      result = nil
+      Bundler.with_clean_env do
+        self.override_ENV.each do |key, value|
+          unless %w{RAILS_ENV RACK_ENV}.include? key
+            self.logger.debug "setup_env: setting ENV[#{key.inspect}] = #{value.inspect}"
+            ENV[key] = value
+          end
+        end
+        rails_env = self.env.to_s
+        ENV['RAILS_ENV'] = ENV['RACK_ENV'] = rails_env
+        self.logger.debug "setup_env: setting ENV['RAILS_ENV'] = ENV['RACK_ENV'] = #{rails_env.inspect}"
+        ENV['RAILS_LTS'] = if @version =~ /lts/ then
+                             'true'
+                           elsif @version =~ /^2\.3/
+                             'false'
+                           else
+                             nil
+                           end
+        ENV['GEM_SOURCE'] = @gem_source if ENV['RAILS_LTS']
+        self.logger.debug "setup_env: setting ENV['GEM_SOURCE'] = #{@gem_source.inspect}, ENV['RAILS_LTS'] = #{ENV['RAILS_LTS'].inspect}" if ENV['RAILS_LTS']
+        result = yield
+      end
+      result
+    end
+
+  end
+end

data/lib/railsapp_factory/server_methods.rb

@@ -0,0 +1,82 @@
+require 'tempfile'
+require 'fileutils'
+
+class RailsappFactory
+  module ServerMethods
+
+    attr_reader :pid
+    attr_reader :port
+
+    def stop
+      if alive?
+        self.logger.info "Stopping server (pid #{pid})"
+        Kernel.system "ps -fp #{@pid}" if self.logger.debug?
+        Process.kill('INT', @pid) rescue nil
+        sleep(1)
+        Process.kill('INT', @pid) rescue nil
+        20.times do
+          sleep(1)
+          break unless alive?
+        end
+        if alive?
+          self.logger.info "Gave up waiting (terminating process #{pid} with extreme prejudice)"
+          Process.kill('KILL', @pid) rescue nil
+        end
+        @pid = nil
+      end
+      if @server_handle
+        self.logger.debug 'Closing pipe to server process'
+        Timeout.timeout(@timeout) do
+          @server_handle.close
+        end
+        @server_handle = nil
+      end
+      self.logger.info 'Server has stopped'
+    end
+
+    def start
+      build unless built?
+      # find random unassigned port
+      server = TCPServer.new('127.0.0.1', 0)
+      @port = server.addr[1]
+      server.close
+      unless self.logger.debug?
+        log_dir = File.join(base_dir, 'logs')
+        FileUtils.mkdir_p log_dir
+        file = Tempfile.new(['server_', '.log'], log_dir)
+        @server_logfile = file.path
+        file.close
+      end
+      self.logger.info "Running Rails #{@version} server on port #{port} #{see_log @server_logfile}"
+      exec_arg = defined?(JRUBY_VERSION) ? '' : 'exec'
+      in_app { @server_handle = IO.popen("#{exec_arg} /bin/sh -xc 'exec #{server_command} -p #{port}' #{append_log @server_logfile}", 'w') }
+      @pid = @server_handle.pid
+      # Detach process so alive? will detect if process dies (zombies still accept signals)
+      Process.detach(@pid)
+      serving_requests = false
+      t1 = Time.new
+      while true
+        raise TimeoutError.new("Waiting for server to be available on the port #{see_log @server_logfile}") if t1 + @timeout < Time.new
+        raise RailsappFactory::BuildError.new("Error starting server #{see_log @server_logfile}") unless alive?
+        sleep(1)
+        begin
+          response = Net::HTTP.get(self.uri)
+          if response
+            t2 = Time.new
+            self.logger.info 'Server responded to http GET after %3.1f seconds' % (t2 - t1)
+            serving_requests = true
+            break
+          end
+        rescue Errno::ECONNREFUSED
+          # do nothing
+        rescue Exception => ex
+          self.logger.debug "Ignoring exception #{ex} whilst waiting for server to start"
+        end
+      end
+      Kernel.system 'ps -f' if defined?(JRUBY_VERSION) #DEBUG
+      serving_requests
+    end
+
+  end
+
+end

data/lib/railsapp_factory/string_inquirer.rb

@@ -0,0 +1,26 @@
+class RailsappFactory
+  # Wrapping a string in this class gives you a prettier way to test
+  # for equality. The value returned by <tt>Rails.env</tt> is wrapped
+  # in a StringInquirer object so instead of calling this:
+  #
+  #   Rails.env == 'production'
+  #
+  # you can call this:
+  #
+  #   Rails.env.production?
+  class StringInquirer < String
+    private
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_name.to_s[-1, 1] == '?'
+    end
+
+    def method_missing(method_name, *arguments)
+      if method_name.to_s[-1, 1] == '?'
+        self == method_name.to_s[0..-2]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/railsapp_factory/template_methods.rb

@@ -0,0 +1,54 @@
+require 'fileutils'
+require 'open-uri'
+
+require 'railsapp_factory/build_error'
+
+class RailsappFactory
+  module TemplateMethods
+
+    attr_reader :template
+
+    def process_template
+      if self.template
+        if self.built?
+          if self.version =~ /^2/
+            # recheck config/environment.rb in case the template/s add more config.gem lines
+            use_template 'templates/use_bundler_with_rails23.rb'
+          end
+          self.logger.info "Processing template #{@template}"
+          unless self.system_in_app "sh -xc '.bundle/bin/rake rails:template LOCATION=#{@template}' #{append_log 'template.log'}"
+            raise RailsappFactory::BuildError.new("rake rails:template returned exist status #{$?} #{see_log 'rails_new.log'}")
+          end
+          clear_template
+        else
+          # build actions template
+          self.build
+        end
+      end
+    end
+
+    def append_to_template(text, source="append_to_template")
+      unless @template
+        template_dir = File.join(base_dir, 'templates')
+        FileUtils.mkdir_p(template_dir) unless File.directory?(template_dir)
+        @template = Tempfile.new('append_', template_dir).path + '.rb'
+      end
+      open(@template, 'a+') do |f|
+        f.puts "\n# #{source}:"
+        f.puts text
+      end
+    end
+
+    def use_template(template)
+      append_to_template(open(template).read, "use_template(#{template}")
+    end
+
+    protected
+
+    def clear_template
+      @template = nil
+    end
+
+  end
+
+end

data/lib/railsapp_factory/version.rb

@@ -0,0 +1,3 @@
+class RailsappFactory
+  VERSION = '0.0.1'
+end

data/lib/railsapp_factory.rb

@@ -0,0 +1,50 @@
+require 'bundler'
+require 'logger'
+
+require 'railsapp_factory/class_methods'
+
+require 'railsapp_factory/build_methods'
+require 'railsapp_factory/helper_methods'
+require 'railsapp_factory/run_in_app_methods'
+require 'railsapp_factory/server_methods'
+require 'railsapp_factory/string_inquirer'
+require 'railsapp_factory/template_methods'
+
+require 'railsapp_factory/build_error'
+
+require 'railsapp_factory/version'
+
+class RailsappFactory
+
+  extend RailsappFactory::ClassMethods
+  include RailsappFactory::BuildMethods
+  include RailsappFactory::HelperMethods
+  include RailsappFactory::RunInAppMethods
+  include RailsappFactory::ServerMethods
+  include RailsappFactory::TemplateMethods
+
+  TMPDIR = File.expand_path('tmp/railsapps')
+
+  attr_reader :version # version requested, may be specific release, or the first part of a release number
+
+  def initialize(version = nil, logger = Logger.new(STDERR))
+    self.logger = logger
+    @version = version
+    unless @version
+      @version = RailsappFactory.versions(RUBY_VERSION).last || '4.0'
+    end
+    self.logger.info("RailsappFactory.new(#{version.inspect}) called - version set to #{@version}")
+    raise ArgumentError.new("Invalid version (#{@version})") if @version.to_s !~ /^[2-9](\.\d+){1,2}(-lts)?$/
+    self.gem_source = 'https://rubygems.org'
+    self.db = defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'
+    # 5 minutes
+    self.timeout = 300
+    # clears build vars
+    destroy
+    # clear template vars
+    clear_template
+    # use default ruby
+    use(nil)
+  end
+
+end

data/railsapp_factory.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'railsapp_factory/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'railsapp_factory'
+  spec.version       = RailsappFactory::VERSION
+  spec.authors       = ['Ian Heggie']
+  spec.email         = ['ian@heggie.biz']
+  spec.description   = %q{Rails application factory to make testing gems against multiple versions easier}
+  spec.summary       = %q{The prupose of this gem is to make integration testing of gems and libraries against multiple versions of rails easy and avoid having to keep copies of the framework in the gem being tested}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'bundler', '~> 1.3'
+  spec.add_dependency 'json_pure'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2.12'
+end

data/spec/railsapp_factory/class_methods_spec.rb

@@ -0,0 +1,121 @@
+require 'rspec'
+require "spec_helper"
+require 'railsapp_factory/class_methods'
+
+describe 'RailsappFactory::ClassMethods' do
+
+  class SubjectClass
+    extend RailsappFactory::ClassMethods
+  end
+
+  describe '::versions' do
+
+    it "should list some rails versions that are compatible with ruby #{RUBY_VERSION}" do
+      list = SubjectClass.versions
+      list.should be_a_kind_of(Array)
+      list.should_not be_empty
+    end
+
+    it 'should return an empty list for unknown ruby versions' do
+      list = SubjectClass.versions('1.5.0')
+      list.should be_a_kind_of(Array)
+      list.should be_empty
+    end
+
+    # taken from http://www.devalot.com/articles/2012/03/ror-compatibility
+    {
+        '1.something' => [],
+        '1.8.6' => %w{2.3},
+        '1.8.7' => %w{2.3 2.3-lts 3.0 3.1 3.2},
+        '1.9.1' => %w{2.3},
+        '1.9.2' => %w{3.0 3.1 3.2},
+        '1.9.3' => %w{3.0 3.1 3.2 4.0},
+        '2.0.x' => %w{4.0},
+        'unknown' => %w{4.0},
+        '' => %w{2.3 2.3-lts 3.0 3.1 3.2 4.0}
+    }.each do |ruby_v, expected|
+      it "should list rails versions that are compatible with ruby #{ruby_v}" do
+        list = SubjectClass.versions(ruby_v)
+        list.should be_a_kind_of(Array)
+        list.should == expected
+      end
+    end
+
+  end
+
+  describe '::rubies' do
+
+    it 'should list some ruby versions' do
+      list = SubjectClass.rubies
+      list.should be_a_kind_of(Array)
+      list.should_not be_empty
+    end
+
+    #it 'should return an empty list for unknown rails versions' do
+    #  list = SubjectClass.rubies('1.5.0')
+    #  list.should be_a_kind_of(Array)
+    #  list.should be_empty
+    #end
+
+    #SubjectClass.versions(nil).each do |rails_v|
+    #  it "should only list ruby versions that are compatible with rails #{rails_v}" do
+    #    SubjectClass.rubies(rails_v).each do |ruby_v|
+    #      SubjectClass.versions(ruby_v).should include(rails_v)
+    #    end
+    #  end
+    #end
+  end
+
+  it '::ruby_command_prefix should return a string' do
+    res = SubjectClass.ruby_command_prefix
+    res.should be_a(String)
+  end
+
+  it '::has_ruby_version_manager? should return a Boolean' do
+    res = SubjectClass.has_ruby_version_manager?
+    res.should be_a(res ? TrueClass : FalseClass)
+  end
+
+  it '::using_system_ruby? should return a Boolean' do
+    res = SubjectClass.using_system_ruby?
+    res.should be_a(res ? TrueClass : FalseClass)
+  end
+
+  describe '::ruby_command_prefix' do
+    include ::SpecHelper
+
+    SubjectClass.rubies.each do |ruby_v|
+      it "provides a command prefix that will run ruby #{ruby_v}" do
+        prefix = SubjectClass.ruby_command_prefix(ruby_v)
+        #puts "RailsappFactory.ruby_command_prefix(#{ruby_v}) = '#{prefix}'"
+        actual_ruby_v=`#{prefix} ruby -v`
+        actual_version_should_match_rubies_version(actual_ruby_v, ruby_v)
+      end
+    end
+
+  end
+
+  describe '::encode_query' do
+
+    it 'should encode a simple argument' do
+      SubjectClass.encode_query(:ian => 23).should == '?ian=23'
+    end
+
+    it 'should encode a nested argument' do
+      SubjectClass.encode_query(:author => {:ian => 23}).should == '?author%5Bian%5D=23'
+    end
+
+    it 'should encode a multiple arguments' do
+      res = SubjectClass.encode_query(:ian => 23, :john => '45')
+      #order not guaranteed
+      if res =~ /^.ian/
+        res.should == '?ian=23&john=45'
+      else
+        res.should == '?john=45&ian=23'
+      end
+    end
+
+  end
+
+end
+