isolation_test 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= Isolation
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,58 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Isolation'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => 'test:isolated'
+# task :default => :test
+# task :test => 'test:isolated'
+
+## This is required until the regular test task
+## below passes.  It's not ideal, but at least
+## we can see the failures
+namespace :test do
+  task :isolated do
+    dir = ENV["TEST_DIR"] || "**"
+    Dir["test/#{dir}/*_test.rb"].each do |file|
+      next true if file.include?("fixtures")
+      dash_i = [
+        'test',
+        'lib',
+        # "#{File.dirname(__FILE__)}/../activesupport/lib",
+        # "#{File.dirname(__FILE__)}/../actionpack/lib"
+      ]
+      ruby "-I#{dash_i.join ':'}", file
+    end
+  end
+end

data/lib/isolation.rb

@@ -0,0 +1,3 @@
+module Isolation
+  
+end

data/lib/isolation/abstract_unit.rb

@@ -0,0 +1,289 @@
+# Note:
+# It is important to keep this file as light as possible
+# the goal for tests that require this is to test booting up
+# rails from an empty state, so anything added here could
+# hide potential failures
+#
+# It is also good to know what is the bare minimum to get
+# Rails booted up.
+require 'fileutils'
+
+require 'rubygems'
+require 'minitest/autorun'
+require 'active_support/test_case'
+
+RAILS_BIN = Gem.bin_path('rails', 'rails')
+
+# These files do not require any others and are needed
+# to run the tests
+require 'active_support/testing/isolation'
+require 'active_support/testing/declarative'
+require 'active_support/core_ext/kernel/reporting'
+
+module TestHelpers
+  module Paths
+    module_function
+
+    TMP_PATH = File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. tmp]))
+
+    def tmp_path(*args)
+      File.join(TMP_PATH, *args)
+    end
+
+    def app_path(*args)
+      tmp_path(*%w[app] + args)
+    end
+
+    def framework_path
+      File.join(Gem.loaded_specs['rails'].full_gem_path, 'lib')
+    end
+
+    def rails_root
+      app_path
+    end
+  end
+
+  module Rack
+    def app(env = "production")
+      old_env = ENV["RAILS_ENV"]
+      @app ||= begin
+        ENV["RAILS_ENV"] = env
+        require "#{app_path}/config/environment"
+        Rails.application
+      end
+    ensure
+      ENV["RAILS_ENV"] = old_env
+    end
+
+    def extract_body(response)
+      "".tap do |body|
+        response[2].each {|chunk| body << chunk }
+      end
+    end
+
+    def get(path)
+      @app.call(::Rack::MockRequest.env_for(path))
+    end
+
+    def assert_welcome(resp)
+      assert_equal 200, resp[0]
+      assert resp[1]["Content-Type"] = "text/html"
+      assert extract_body(resp).match(/Welcome aboard/)
+    end
+
+    def assert_success(resp)
+      assert_equal 202, resp[0]
+    end
+
+    def assert_missing(resp)
+      assert_equal 404, resp[0]
+    end
+
+    def assert_header(key, value, resp)
+      assert_equal value, resp[1][key.to_s]
+    end
+
+    def assert_body(expected, resp)
+      assert_equal expected, extract_body(resp)
+    end
+  end
+
+  module Generation
+    # Build an application by invoking the generator and going through the whole stack.
+    def build_app(options = {})
+      @prev_rails_env = ENV['RAILS_ENV']
+      ENV['RAILS_ENV'] = 'development'
+
+      FileUtils.rm_rf(app_path)
+      FileUtils.cp_r(tmp_path('app_template'), app_path)
+
+      # Delete the initializers unless requested
+      unless options[:initializers]
+        Dir["#{app_path}/config/initializers/*.rb"].each do |initializer|
+          File.delete(initializer)
+        end
+      end
+
+      unless options[:gemfile]
+        File.delete"#{app_path}/Gemfile"
+      end
+
+      routes = File.read("#{app_path}/config/routes.rb")
+      if routes =~ /(\n\s*end\s*)\Z/
+        File.open("#{app_path}/config/routes.rb", 'w') do |f|
+          f.puts $` + "\nmatch ':controller(/:action(/:id))(.:format)'\n" + $1
+        end
+      end
+
+      add_to_config 'config.secret_token = "3b7cd727ee24e8444053437c36cc66c4"; config.session_store :cookie_store, :key => "_myapp_session"; config.active_support.deprecation = :log'
+    end
+
+    def teardown_app
+      ENV['RAILS_ENV'] = @prev_rails_env if @prev_rails_env
+    end
+
+    # Make a very basic app, without creating the whole directory structure.
+    # This is faster and simpler than the method above.
+    def make_basic_app
+      require "rails"
+      require "action_controller/railtie"
+
+      app = Class.new(Rails::Application)
+      app.config.secret_token = "3b7cd727ee24e8444053437c36cc66c4"
+      app.config.session_store :cookie_store, :key => "_myapp_session"
+      app.config.active_support.deprecation = :log
+
+      yield app if block_given?
+      app.initialize!
+
+      app.routes.draw do
+        match "/" => "omg#index"
+      end
+
+      require 'rack/test'
+      extend ::Rack::Test::Methods
+    end
+
+    def simple_controller
+      controller :foo, <<-RUBY
+        class FooController < ApplicationController
+          def index
+            render :text => "foo"
+          end
+        end
+      RUBY
+
+      app_file 'config/routes.rb', <<-RUBY
+        AppTemplate::Application.routes.draw do
+          match ':controller(/:action)'
+        end
+      RUBY
+    end
+
+    class Bukkit
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      def write(file, string)
+        path = "#{@path}/#{file}"
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, "w") {|f| f.puts string }
+      end
+
+      def delete(file)
+        File.delete("#{@path}/#{file}")
+      end
+    end
+
+    def engine(name)
+      dir = "#{app_path}/random/#{name}"
+      FileUtils.mkdir_p(dir)
+
+      app = File.readlines("#{app_path}/config/application.rb")
+      app.insert(2, "$:.unshift(\"#{dir}/lib\")")
+      app.insert(3, "require #{name.inspect}")
+
+      File.open("#{app_path}/config/application.rb", 'r+') do |f|
+        f.puts app
+      end
+
+      Bukkit.new(dir).tap do |bukkit|
+        yield bukkit if block_given?
+      end
+    end
+
+    def script(script)
+      Dir.chdir(app_path) do
+        `#{Gem.ruby} #{app_path}/script/rails #{script}`
+      end
+    end
+
+    def add_to_config(str)
+      environment = File.read("#{app_path}/config/application.rb")
+      if environment =~ /(\n\s*end\s*end\s*)\Z/
+        File.open("#{app_path}/config/application.rb", 'w') do |f|
+          f.puts $` + "\n#{str}\n" + $1
+        end
+      end
+    end
+
+    def add_to_env_config(env, str)
+      environment = File.read("#{app_path}/config/environments/#{env}.rb")
+      if environment =~ /(\n\s*end\s*)\Z/
+        File.open("#{app_path}/config/environments/#{env}.rb", 'w') do |f|
+          f.puts $` + "\n#{str}\n" + $1
+        end
+      end
+    end
+
+    def remove_from_config(str)
+      file = "#{app_path}/config/application.rb"
+      contents = File.read(file)
+      contents.sub!(/#{str}/, "")
+      File.open(file, "w+") { |f| f.puts contents }
+    end
+
+    def app_file(path, contents)
+      FileUtils.mkdir_p File.dirname("#{app_path}/#{path}")
+      File.open("#{app_path}/#{path}", 'w') do |f|
+        f.puts contents
+      end
+    end
+
+    def remove_file(path)
+      FileUtils.rm_rf "#{app_path}/#{path}"
+    end
+
+    def controller(name, contents)
+      app_file("app/controllers/#{name}_controller.rb", contents)
+    end
+
+    def use_frameworks(arr)
+      to_remove =  [:actionmailer,
+                    :activemodel,
+                    :activerecord,
+                    :activeresource] - arr
+      remove_from_config "config.active_record.identity_map = true" if to_remove.include? :activerecord
+      $:.reject! {|path| path =~ %r'/(#{to_remove.join('|')})/' }
+    end
+
+    def boot_rails
+      require File.expand_path('../load_paths', __FILE__)
+    end
+  end
+end
+
+class ActiveSupport::TestCase
+  include TestHelpers::Paths
+  include TestHelpers::Rack
+  include TestHelpers::Generation
+  extend  ActiveSupport::Testing::Declarative
+end
+
+# Create a scope and build a fixture rails app
+Module.new do
+  extend TestHelpers::Paths
+  # Build a rails app
+  if File.exist?(tmp_path)
+    FileUtils.rm_rf(tmp_path)
+  end
+  FileUtils.mkdir(tmp_path)
+
+  environment = File.expand_path('../load_paths', __FILE__)
+  if File.exist?("#{environment}.rb")
+    require_environment = "-r #{environment}"
+  end
+
+  `#{Gem.ruby} #{require_environment} #{RAILS_BIN} new #{tmp_path('app_template')}`
+  File.open("#{tmp_path}/app_template/config/boot.rb", 'w') do |f|
+    if require_environment
+      f.puts "Dir.chdir('#{File.dirname(environment)}') do"
+      f.puts "  require '#{environment}'"
+      f.puts "end"
+    end
+    f.puts "require 'rails/all'"
+  end
+end unless defined?(RAILS_ISOLATED_ENGINE)

data/lib/isolation/load_paths.rb

@@ -0,0 +1,4 @@
+# bust gem prelude
+require 'rubygems' unless defined? Gem
+require 'bundler'
+Bundler.setup

data/lib/isolation/version.rb

@@ -0,0 +1,3 @@
+module Isolation
+  VERSION = "0.1.0"
+end

data/lib/tasks/isolation_tasks.rake

@@ -0,0 +1,18 @@
+## This is required until the regular test task
+## below passes.  It's not ideal, but at least
+## we can see the failures
+namespace :isolation do
+  task :test do
+    dir = ENV["TEST_DIR"] || "**"
+    Dir["test/#{dir}/*_test.rb"].each do |file|
+      next true if file.include?("fixtures")
+      dash_i = [
+        'test',
+        # 'lib',
+        # "#{File.dirname(__FILE__)}/../activesupport/lib",
+        # "#{File.dirname(__FILE__)}/../actionpack/lib"
+      ]
+      ruby "-I#{dash_i.join ':'}", file
+    end
+  end
+end

data/test/isolation_test.rb

@@ -0,0 +1,15 @@
+require 'isolation/abstract_unit'
+
+class IsolationTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  def setup
+    build_app
+    boot_rails
+  end
+
+  def teardown
+    teardown_app
+  end
+
+end

data/test/rails_loading_test.rb

@@ -0,0 +1,116 @@
+require 'isolation/abstract_unit'
+
+# This is a sample test taken from
+# https://github.com/rails/rails/tree/v3.1.3/railties/test
+# application/loading_test.rb
+class RailsLoadingTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  def setup
+    build_app
+    boot_rails
+  end
+
+  def teardown
+    teardown_app
+  end
+
+  def app
+     @app ||= Rails.application
+   end
+
+   def test_constants_in_app_are_autoloaded
+     app_file "app/models/post.rb", <<-MODEL
+       class Post < ActiveRecord::Base
+         validates_acceptance_of :title, :accept => "omg"
+       end
+     MODEL
+
+     require "#{rails_root}/config/environment"
+     setup_ar!
+
+     p = Post.create(:title => 'omg')
+     assert_equal 1, Post.count
+     assert_equal 'omg', p.title
+     p = Post.first
+     assert_equal 'omg', p.title
+   end
+
+   def test_models_without_table_do_not_panic_on_scope_definitions_when_loaded
+     app_file "app/models/user.rb", <<-MODEL
+       class User < ActiveRecord::Base
+         default_scope where(:published => true)
+       end
+     MODEL
+
+     require "#{rails_root}/config/environment"
+     setup_ar!
+
+     User
+   end
+
+   test "load config/environments/environment before Bootstrap initializers" do
+     app_file "config/environments/development.rb", <<-RUBY
+       AppTemplate::Application.configure do
+         config.development_environment_loaded = true
+       end
+     RUBY
+
+     add_to_config <<-RUBY
+       config.before_initialize do
+         config.loaded = config.development_environment_loaded
+       end
+     RUBY
+
+     require "#{app_path}/config/environment"
+     assert ::AppTemplate::Application.config.loaded
+   end
+
+   def test_descendants_are_cleaned_on_each_request_without_cache_classes
+     add_to_config <<-RUBY
+       config.cache_classes = false
+     RUBY
+
+     app_file "app/models/post.rb", <<-MODEL
+       class Post < ActiveRecord::Base
+       end
+     MODEL
+
+     app_file 'config/routes.rb', <<-RUBY
+       AppTemplate::Application.routes.draw do
+         match '/load',   :to => lambda { |env| [200, {}, Post.all] }
+         match '/unload', :to => lambda { |env| [200, {}, []] }
+       end
+     RUBY
+
+     require 'rack/test'
+     extend Rack::Test::Methods
+
+     require "#{rails_root}/config/environment"
+     setup_ar!
+
+     assert_equal [], ActiveRecord::Base.descendants
+     get "/load"
+     assert_equal [Post], ActiveRecord::Base.descendants
+     get "/unload"
+     assert_equal [], ActiveRecord::Base.descendants
+   end
+
+   test "initialize_cant_be_called_twice" do
+     require "#{app_path}/config/environment"
+     assert_raise(RuntimeError) { ::AppTemplate::Application.initialize! }
+   end
+
+   protected
+
+   def setup_ar!
+     ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+     ActiveRecord::Migration.verbose = false
+     ActiveRecord::Schema.define(:version => 1) do
+       create_table :posts do |t|
+         t.string :title
+       end
+     end
+   end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+# # Configure Rails Environment
+# ENV["RAILS_ENV"] = "test"
+# 
+# require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+# require "rails/test_help"
+# 
+# Rails.backtrace_cleaner.remove_silencers!
+# 
+# # Load support files
+# Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: isolation_test
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Reinaldo de Souza Junior
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70294749505920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *70294749505920
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70294749505480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70294749505480
+description: 
+email:
+- juniorz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/isolation/abstract_unit.rb
+- lib/isolation/load_paths.rb
+- lib/isolation/version.rb
+- lib/isolation.rb
+- lib/tasks/isolation_tasks.rake
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+- test/isolation_test.rb
+- test/rails_loading_test.rb
+- test/test_helper.rb
+homepage: https://github.com/juniorz/isolation_test
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 253863503296580160
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 253863503296580160
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Testing Rails::Engine boot proccess.
+test_files:
+- test/isolation_test.rb
+- test/rails_loading_test.rb
+- test/test_helper.rb