hashrocket-clearance 0.4.3 → 0.4.4

data/test/rails_root/vendor/gems/thoughtbot-shoulda-2.0.4/test/other/private_helpers_test.rb

@@ -1,34 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-class PrivateHelpersTest < Test::Unit::TestCase # :nodoc:
-  include ThoughtBot::Shoulda::Private
-  context "get_options!" do
-    should "remove opts from args" do
-      args = [:a, :b, {}]
-      get_options!(args)
-      assert_equal [:a, :b], args
-    end
-
-    should "return wanted opts in order" do
-      args = [{:one => 1, :two => 2}]
-      one, two = get_options!(args, :one, :two)
-      assert_equal 1, one
-      assert_equal 2, two
-    end
-
-    should "raise ArgumentError if given unwanted option" do
-      args = [{:one => 1, :two => 2}]
-      assert_raises ArgumentError do
-        get_options!(args, :one)
-      end
-    end
-  end
-
-  class ::SomeModel; end
-  context "model_class" do
-    should "sniff the class constant from the test class" do
-      self.expects(:name).returns("SomeModelTest")
-      assert_equal SomeModel, model_class
-    end
-  end
-end

data/test/rails_root/vendor/gems/thoughtbot-shoulda-2.0.4/test/other/should_test.rb

@@ -1,266 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helper')
-
-class ShouldTest < Test::Unit::TestCase # :nodoc:
-  should "be able to define a should statement outside of a context" do
-    assert true
-  end
-  
-  should "see the name of my class as ShouldTest" do
-    assert_equal "ShouldTest", self.class.name
-  end
-  
-  def self.should_see_class_methods
-    should "be able to see class methods" do
-      assert true
-    end
-  end
-
-  def self.should_see_a_context_block_like_a_Test_Unit_class
-    should "see a context block as a Test::Unit class" do
-      assert_equal "ShouldTest", self.class.name
-    end
-  end
-
-  def self.should_see_blah
-    should "see @blah through a macro" do
-      assert @blah 
-    end
-  end
-
-  def self.should_not_see_blah
-    should "not see @blah through a macro" do
-      assert_nil @blah 
-    end
-  end
-
-  def self.should_be_able_to_make_context_macros(prefix = nil)
-    context "a macro" do
-      should "have the tests named correctly" do
-        assert_match(/^test: #{prefix}a macro should have the tests named correctly/, self.to_s)
-      end
-    end
-  end
-
-  context "Context" do
-
-    should_see_class_methods
-    should_see_a_context_block_like_a_Test_Unit_class
-    should_be_able_to_make_context_macros("Context ")
-
-    should "not define @blah" do
-      assert ! self.instance_variables.include?("@blah")
-    end
-
-    should_not_see_blah
-
-    should "be able to define a should statement" do
-      assert true
-    end
-
-    should "see the name of my class as ShouldTest" do
-      assert_equal "ShouldTest", self.class.name
-    end
-
-    context "with a subcontext" do
-      should_be_able_to_make_context_macros("Context with a subcontext ")
-    end
-  end
-
-  context "Context with setup block" do
-    setup do
-      @blah = "blah"
-    end
-    
-    should "have @blah == 'blah'" do
-      assert_equal "blah", @blah
-    end
-    should_see_blah
-    
-    should "have name set right" do
-      assert_match(/^test: Context with setup block/, self.to_s)
-    end
-
-    context "and a subcontext" do
-      setup do
-        @blah = "#{@blah} twice"
-      end
-      
-      should "be named correctly" do
-        assert_match(/^test: Context with setup block and a subcontext should be named correctly/, self.to_s)
-      end
-      
-      should "run the setup methods in order" do
-        assert_equal @blah, "blah twice"
-      end
-      should_see_blah
-    end
-  end
-
-  context "Another context with setup block" do
-    setup do
-      @blah = "foo"
-    end
-    
-    should "have @blah == 'foo'" do
-      assert_equal "foo", @blah
-    end
-
-    should "have name set right" do
-      assert_match(/^test: Another context with setup block/, self.to_s)
-    end
-    should_see_blah
-  end
-  
-  should_eventually "pass, since it's a should_eventually" do
-    flunk "what?"
-  end
-
-  # Context creation and naming
-
-  def test_should_create_a_new_context
-    assert_nothing_raised do
-      Thoughtbot::Shoulda::Context.new("context name", self) do; end
-    end
-  end
-
-  def test_should_create_a_nested_context
-    assert_nothing_raised do
-      parent = Thoughtbot::Shoulda::Context.new("Parent", self) do; end
-      child  = Thoughtbot::Shoulda::Context.new("Child", parent) do; end
-    end
-  end
-
-  def test_should_name_a_contexts_correctly
-    parent     = Thoughtbot::Shoulda::Context.new("Parent", self) do; end
-    child      = Thoughtbot::Shoulda::Context.new("Child", parent) do; end
-    grandchild = Thoughtbot::Shoulda::Context.new("GrandChild", child) do; end
-
-    assert_equal "Parent", parent.full_name
-    assert_equal "Parent Child", child.full_name
-    assert_equal "Parent Child GrandChild", grandchild.full_name
-  end
-
-  # Should statements
-
-  def test_should_have_should_hashes_when_given_should_statements
-    context = Thoughtbot::Shoulda::Context.new("name", self) do
-      should "be good" do; end
-      should "another" do; end
-    end
-    
-    names = context.shoulds.map {|s| s[:name]}
-    assert_equal ["another", "be good"], names.sort
-  end
-
-  # setup and teardown
-
-  def test_should_capture_setup_and_teardown_blocks
-    context = Thoughtbot::Shoulda::Context.new("name", self) do
-      setup    do; "setup";    end
-      teardown do; "teardown"; end
-    end
-    
-    assert_equal "setup",    context.setup_blocks.first.call
-    assert_equal "teardown", context.teardown_blocks.first.call
-  end
-
-  # building
-
-  def test_should_create_shoulda_test_for_each_should_on_build
-    context = Thoughtbot::Shoulda::Context.new("name", self) do
-      should "one" do; end
-      should "two" do; end
-    end
-    context.expects(:create_test_from_should_hash).with(has_entry(:name => "one"))
-    context.expects(:create_test_from_should_hash).with(has_entry(:name => "two"))
-    context.build
-  end
-
-  def test_should_create_test_methods_on_build
-    tu_class = Test::Unit::TestCase
-    context = Thoughtbot::Shoulda::Context.new("A Context", tu_class) do
-      should "define the test" do; end
-    end
-
-    tu_class.expects(:define_method).with(:"test: A Context should define the test. ")
-    context.build
-  end
-
-  def test_should_create_test_methods_on_build_when_subcontext
-    tu_class = Test::Unit::TestCase
-    context = Thoughtbot::Shoulda::Context.new("A Context", tu_class) do
-      context "with a child" do
-        should "define the test" do; end
-      end
-    end
-
-    tu_class.expects(:define_method).with(:"test: A Context with a child should define the test. ")
-    context.build
-  end
-
-  # Test::Unit integration
-
-  def test_should_create_a_new_context_and_build_it_on_Test_Unit_context
-    c = mock("context")
-    c.expects(:build)
-    Thoughtbot::Shoulda::Context.expects(:new).with("foo", kind_of(Class)).returns(c)
-    self.class.context "foo" do; end
-  end
-
-  def test_should_create_a_one_off_context_and_build_it_on_Test_Unit_should
-    s = mock("test")
-    Thoughtbot::Shoulda::Context.any_instance.expects(:should).with("rock", {}).returns(s)
-    Thoughtbot::Shoulda::Context.any_instance.expects(:build)
-    self.class.should "rock" do; end
-  end
-
-  def test_should_create_a_one_off_context_and_build_it_on_Test_Unit_should_eventually
-    s = mock("test")
-    Thoughtbot::Shoulda::Context.any_instance.expects(:should_eventually).with("rock").returns(s)
-    Thoughtbot::Shoulda::Context.any_instance.expects(:build)
-    self.class.should_eventually "rock" do; end
-  end
-
-  should "run a :before proc", :before => lambda { @value = "before" } do
-    assert_equal "before", @value
-  end
-
-  context "A :before proc" do
-    setup do
-      assert_equal "before", @value
-      @value = "setup"
-    end
-
-    should "run before the current setup", :before => lambda { @value = "before" } do
-      assert_equal "setup", @value
-    end
-  end
-
-  context "a before statement" do
-    setup do
-      assert_equal "before", @value
-      @value = "setup"
-    end
-
-    before_should "run before the current setup" do
-      @value = "before"
-    end
-  end
-
-  context "A context" do
-    setup do
-      @value = "outer"
-    end
-
-    context "with a subcontext and a :before proc" do
-      before = lambda do
-        assert "outer", @value
-        @value = "before"
-      end
-      should "run after the parent setup", :before => before do
-        assert_equal "before", @value
-      end
-    end
-  end
-
-end

data/test/rails_root/vendor/gems/thoughtbot-shoulda-2.0.4/test/rails_root/app/controllers/application.rb

@@ -1,25 +0,0 @@
-# Filters added to this controller apply to all controllers in the application.
-# Likewise, all the methods added will be available for all controllers.
-
-class ApplicationController < ActionController::Base
-  # Pick a unique cookie name to distinguish our session data from others'
-  session :session_key => '_rails_root_session_id'
-  
-  def ensure_logged_in
-    unless session[:logged_in]
-      respond_to do |accepts|
-        accepts.html do
-          flash[:error] = 'What do you think you\'re doing?'
-          redirect_to '/'
-        end
-        accepts.xml do
-          headers["Status"]           = "Unauthorized"
-          headers["WWW-Authenticate"] = %(Basic realm="Web Password")
-          render :text => "Couldn't authenticate you", :status => '401 Unauthorized'
-        end
-      end
-      return false
-    end
-    return true
-  end
-end

data/test/rails_root/vendor/gems/thoughtbot-shoulda-2.0.4/test/rails_root/app/controllers/posts_controller.rb

@@ -1,85 +0,0 @@
-class PostsController < ApplicationController
-  before_filter :ensure_logged_in
-  before_filter :load_user
-  
-  def index
-    @posts = @user.posts
-
-    respond_to do |format|
-      format.html # index.rhtml
-      format.xml  { render :xml => @posts.to_xml }
-      format.rss do
-        headers['Content-Type'] = 'application/rss+xml'
-        session[:special] = '$2 off your next purchase'
-        session[:special_user_id] = @user.id
-        head :ok
-      end
-    end
-  end
-
-  def show
-    @post = @user.posts.find(params[:id])
-
-    respond_to do |format|
-      format.html { render :layout => 'wide' }
-      format.xml  { render :xml => @post.to_xml }
-    end
-  end
-
-  def new
-    @post = @user.posts.build
-    render :layout => false
-  end
-
-  def edit
-    @post = @user.posts.find(params[:id])
-  end
-
-  def create
-    @post = @user.posts.build(params[:post])
-
-    respond_to do |format|
-      if @post.save
-        flash[:notice] = 'Post was successfully created.'
-        format.html { redirect_to user_post_url(@post.user, @post) }
-        format.xml  { head :created, :location => user_post_url(@post.user, @post) }
-      else
-        format.html { render :action => "new" }
-        format.xml  { render :xml => @post.errors.to_xml }
-      end
-    end
-  end
-
-  def update
-    @post = @user.posts.find(params[:id])
-
-    respond_to do |format|
-      if @post.update_attributes(params[:post])
-        flash[:notice] = 'Post was successfully updated.'
-        format.html { redirect_to user_post_url(@post.user, @post) }
-        format.xml  { head :ok }
-      else
-        format.html { render :action => "edit" }
-        format.xml  { render :xml => @post.errors.to_xml }
-      end
-    end
-  end
-
-  def destroy
-    @post = @user.posts.find(params[:id])
-    @post.destroy
-    
-    flash[:notice] = "Post was removed"
-    
-    respond_to do |format|
-      format.html { redirect_to user_posts_url(@post.user) }
-      format.xml  { head :ok }
-    end
-  end
-  
-  private
-  
-  def load_user
-    @user = User.find(params[:user_id])
-  end
-end

data/test/rails_root/vendor/gems/thoughtbot-shoulda-2.0.4/test/rails_root/app/controllers/users_controller.rb

@@ -1,84 +0,0 @@
-class UsersController < ApplicationController
-  
-  filter_parameter_logging :ssn
-  
-  # GET /users
-  # GET /users.xml
-  def index
-    @users = User.find(:all)
-
-    respond_to do |format|
-      format.html # index.rhtml
-      format.xml  { render :xml => @users.to_xml }
-    end
-  end
-
-  # GET /users/1
-  # GET /users/1.xml
-  def show
-    @user = User.find(params[:id])
-
-    respond_to do |format|
-      format.html # show.rhtml
-      format.xml  { render :xml => @user.to_xml }
-    end
-  end
-
-  # GET /users/new
-  def new
-    @user = User.new
-  end
-
-  # GET /users/1;edit
-  def edit
-    @user = User.find(params[:id])
-  end
-
-  # POST /users
-  # POST /users.xml
-  def create
-    @user = User.new(params[:user])
-
-    respond_to do |format|
-      if @user.save
-        flash[:notice] = 'User was successfully created.'
-        format.html { redirect_to user_url(@user) }
-        format.xml  { head :created, :location => user_url(@user) }
-      else
-        format.html { render :action => "new" }
-        format.xml  { render :xml => @user.errors.to_xml }
-      end
-    end
-  end
-
-  # PUT /users/1
-  # PUT /users/1.xml
-  def update
-    @user = User.find(params[:id])
-
-    respond_to do |format|
-      if @user.update_attributes(params[:user])
-        flash[:notice] = 'User was successfully updated.'
-        format.html { redirect_to user_url(@user) }
-        format.xml  { head :ok }
-      else
-        format.html { render :action => "edit" }
-        format.xml  { render :xml => @user.errors.to_xml }
-      end
-    end
-  end
-
-  # DELETE /users/1
-  # DELETE /users/1.xml
-  def destroy
-    @user = User.find(params[:id])
-    @user.destroy
-
-    flash[:notice] = "User was removed"
-
-    respond_to do |format|
-      format.html { redirect_to users_url }
-      format.xml  { head :ok }
-    end
-  end
-end