picolena 0.1.8 → 0.2.0

data/rails_plugins/rspec_on_rails/spec/rails/autotest/rails_rspec_spec.rb

@@ -1,8 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require File.join(File.dirname(__FILE__), "..", "..", "..", "lib", "autotest", "rails_rspec")
-
-describe Autotest::RailsRspec do
-  it "should provide the correct spec_command" do
-    Autotest::RailsRspec.new.spec_command.should == "script/spec"
-  end
-end

data/rails_plugins/rspec_on_rails/spec/rails/example/assigns_hash_proxy_spec.rb

@@ -1,55 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "An AssignsHashProxy" do
-  before(:each) do
-    @object = Object.new
-    @assigns = Hash.new
-    @object.stub!(:assigns).and_return(@assigns)
-    @proxy = Spec::Rails::Example::AssignsHashProxy.new(@object)
-  end
-
-  it "has [] accessor" do
-    @proxy['foo'] = 'bar'
-    @assigns['foo'].should == 'bar'
-    @proxy['foo'].should == 'bar'
-  end
-
-  it "works for symbol key" do
-    @assigns[:foo] = 2
-    @proxy[:foo].should == 2
-  end
-
-  it "checks for string key before symbol key" do
-    @assigns['foo'] = false
-    @assigns[:foo] = 2
-    @proxy[:foo].should == false
-  end
-
-  it "each method iterates through each element like a Hash" do
-    values = {
-      'foo' => 1,
-      'bar' => 2,
-      'baz' => 3
-    }
-    @proxy['foo'] = values['foo']
-    @proxy['bar'] = values['bar']
-    @proxy['baz'] = values['baz']
-
-    @proxy.each do |key, value|
-      key.should == key
-      value.should == values[key]
-    end
-  end
-
-  it "delete method deletes the element of passed in key" do
-    @proxy['foo'] = 'bar'
-    @proxy.delete('foo').should == 'bar'
-    @proxy['foo'].should be_nil
-  end
-
-  it "has_key? detects the presence of a key" do
-    @proxy['foo'] = 'bar'
-    @proxy.has_key?('foo').should == true
-    @proxy.has_key?('bar').should == false
-  end
-end

data/rails_plugins/rspec_on_rails/spec/rails/example/configuration_spec.rb

@@ -1,83 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module Example
-    describe Configuration, :shared => true do
-      before(:each) { @config = Configuration.new }
-    end
-
-    describe Configuration, "#use_transactional_fixtures" do
-      it_should_behave_like "Spec::Example::Configuration"
-
-      it "should return Test::Unit::TestCase.use_transactional_fixtures" do
-        @config.use_transactional_fixtures.should == Test::Unit::TestCase.use_transactional_fixtures
-      end
-
-      it "should set Test::Unit::TestCase.use_transactional_fixtures to false" do
-        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-          example_group.should_receive(:use_transactional_fixtures=).with(false)
-        end
-        @config.use_transactional_fixtures = false
-      end
-
-      it "should set Test::Unit::TestCase.use_transactional_fixtures to true" do
-        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-          example_group.should_receive(:use_transactional_fixtures=).with(true)
-        end
-        @config.use_transactional_fixtures = true
-      end
-    end
-
-    describe Configuration, "#use_instantiated_fixtures" do
-      it_should_behave_like "Spec::Example::Configuration"
-
-      it "should return Test::Unit::TestCase.use_transactional_fixtures" do
-        @config.use_instantiated_fixtures.should == Test::Unit::TestCase.use_instantiated_fixtures
-      end
-
-      it "should set Test::Unit::TestCase.use_instantiated_fixtures to false" do
-        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-          example_group.should_receive(:use_instantiated_fixtures=).with(false)
-        end
-        @config.use_instantiated_fixtures = false
-      end
-
-      it "should set Test::Unit::TestCase.use_instantiated_fixtures to true" do
-        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-          example_group.should_receive(:use_instantiated_fixtures=).with(true)
-        end
-        @config.use_instantiated_fixtures = true
-      end
-    end
-
-    describe Configuration, "#fixture_path" do
-      it_should_behave_like "Spec::Example::Configuration"
-
-      it "should default to RAILS_ROOT + '/spec/fixtures'" do
-        @config.fixture_path.should == RAILS_ROOT + '/spec/fixtures'
-        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-          example_group.fixture_path.should == RAILS_ROOT + '/spec/fixtures'
-        end
-      end
-
-      it "should set fixture_path" do
-        @config.fixture_path = "/new/path"
-        @config.fixture_path.should == "/new/path"
-        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-          example_group.fixture_path.should == "/new/path"
-        end
-      end
-    end
-
-    describe Configuration, "#global_fixtures" do
-      it_should_behave_like "Spec::Example::Configuration"
-
-      it "should set fixtures on TestCase" do
-        Configuration::EXAMPLE_GROUP_CLASSES.each do |example_group|
-          example_group.should_receive(:fixtures).with(:blah)
-        end
-        @config.global_fixtures = [:blah]
-      end
-    end
-  end
-end

data/rails_plugins/rspec_on_rails/spec/rails/example/controller_isolation_spec.rb

@@ -1,43 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'controller_spec_controller'
-
-describe "a controller spec running in isolation mode", :type => :controller do
-  controller_name :controller_spec
-
-  it "should not care if the template doesn't exist" do
-    get 'some_action'
-    response.should be_success
-    response.should render_template("template/that/does/not/actually/exist")
-  end
-
-  it "should not care if the template has errors" do
-    get 'action_with_errors_in_template'
-    response.should be_success
-    response.should render_template("action_with_errors_in_template")
-  end
-end
-
-describe "a controller spec running in integration mode", :type => :controller do
-  controller_name :controller_spec
-  integrate_views
-
-  before(:each) do
-    controller.class.send(:define_method, :rescue_action) { |e| raise e }
-  end
-
-  it "should render a template" do
-    get 'action_with_template'
-    response.should be_success
-    response.should have_tag('div', 'This is action_with_template.rhtml')
-  end
-
-  it "should choke if the template doesn't exist" do
-    lambda { get 'some_action' }.should raise_error(ActionController::MissingTemplate)
-    response.should_not be_success
-  end
-
-  it "should choke if the template has errors" do
-    lambda { get 'action_with_errors_in_template' }.should raise_error(ActionView::TemplateError)
-    response.should_not be_success
-  end
-end

data/rails_plugins/rspec_on_rails/spec/rails/example/controller_spec_spec.rb

@@ -1,187 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require 'controller_spec_controller'
-
-['integration', 'isolation'].each do |mode|
-  describe "A controller example running in #{mode} mode", :type => :controller do
-    controller_name :controller_spec
-    integrate_views if mode == 'integration'
-
-    it "should provide controller.session as session" do
-      get 'action_with_template'
-      session.should equal(controller.session)
-    end
-
-    it "should provide the same session object before and after the action" do
-      session_before = session
-      get 'action_with_template'
-      session.should equal(session_before)
-    end
-
-    it "should ensure controller.session is NOT nil before the action" do
-      controller.session.should_not be_nil
-      get 'action_with_template'
-    end
-
-    it "should ensure controller.session is NOT nil after the action" do
-      get 'action_with_template'
-      controller.session.should_not be_nil
-    end
-
-    it "should allow specifying a partial with partial name only" do
-      get 'action_with_partial'
-      response.should render_template("_partial")
-    end
-
-    it "should allow specifying a partial with expect_render" do
-      controller.expect_render(:partial => "controller_spec/partial")
-      get 'action_with_partial'
-    end
-
-    it "should allow specifying a partial with expect_render with object" do
-      controller.expect_render(:partial => "controller_spec/partial", :object => "something")
-      get 'action_with_partial_with_object', :thing => "something"
-    end
-
-    it "should allow specifying a partial with expect_render with locals" do
-      controller.expect_render(:partial => "controller_spec/partial", :locals => {:thing => "something"})
-      get 'action_with_partial_with_locals', :thing => "something"
-    end
-
-    it "should yield to render :update" do
-      template = stub("template")
-      controller.expect_render(:update).and_yield(template)
-      template.should_receive(:replace).with(:bottom, "replace_me", :partial => "non_existent_partial")
-      get 'action_with_render_update'
-      puts response.body
-    end
-
-    it "should allow a path relative to RAILS_ROOT/app/views/ when specifying a partial" do
-      get 'action_with_partial'
-      response.should render_template("controller_spec/_partial")
-    end
-
-    it "should provide access to flash" do
-      get 'action_with_template'
-      flash[:flash_key].should == "flash value"
-    end
-
-    it "should provide access to flash values set after a session reset" do
-      get 'action_setting_flash_after_session_reset'
-      flash[:after_reset].should == "available"
-    end
-
-    it "should not provide access to flash values set before a session reset" do
-      get 'action_setting_flash_before_session_reset'
-      flash[:before_reset].should_not == "available"
-    end
-
-    it "should provide access to session" do
-      get 'action_with_template'
-      session[:session_key].should == "session value"
-    end
-
-    it "should support custom routes" do
-      route_for(:controller => "custom_route_spec", :action => "custom_route").should == "/custom_route"
-    end
-
-    it "should support existing routes" do
-      route_for(:controller => "controller_spec", :action => "some_action").should == "/controller_spec/some_action"
-    end
-
-    it "should generate params for custom routes" do
-      params_from(:get, '/custom_route').should == {:controller => "custom_route_spec", :action => "custom_route"}
-    end
-
-    it "should generate params for existing routes" do
-      params_from(:get, '/controller_spec/some_action').should == {:controller => "controller_spec", :action => "some_action"}
-    end
-
-    it "should expose instance vars through the assigns hash" do
-      get 'action_setting_the_assigns_hash'
-      assigns[:indirect_assigns_key].should == :indirect_assigns_key_value
-    end
-
-    it "should expose the assigns hash directly" do
-      get 'action_setting_the_assigns_hash'
-      assigns[:direct_assigns_key].should == :direct_assigns_key_value
-    end
-
-    it "should complain when calling should_receive(:render) on the controller" do
-      lambda {
-        controller.should_receive(:render)
-      }.should raise_error(RuntimeError, /should_receive\(:render\) has been disabled/)
-    end
-
-    it "should complain when calling stub!(:render) on the controller" do
-      lambda {
-        controller.stub!(:render)
-      }.should raise_error(RuntimeError, /stub!\(:render\) has been disabled/)
-    end
-
-    it "should NOT complain when calling should_receive with arguments other than :render" do
-      controller.should_receive(:anything_besides_render)
-      lambda {
-        controller.rspec_verify
-      }.should raise_error(Exception, /expected :anything_besides_render/)
-    end
-  end
-
-  describe "Given a controller spec for RedirectSpecController running in #{mode} mode", :type => :controller do
-    controller_name :redirect_spec
-    integrate_views if mode == 'integration'
-
-    it "a redirect should ignore the absence of a template" do
-      get 'action_with_redirect_to_somewhere'
-      response.should be_redirect
-      response.redirect_url.should == "http://test.host/redirect_spec/somewhere"
-      response.should redirect_to("http://test.host/redirect_spec/somewhere")
-    end
-
-    it "a call to response.should redirect_to should fail if no redirect" do
-      get 'action_with_no_redirect'
-      lambda {
-        response.redirect?.should be_true
-      }.should fail
-      lambda {
-        response.should redirect_to("http://test.host/redirect_spec/somewhere")
-      }.should fail_with("expected redirect to \"http://test.host/redirect_spec/somewhere\", got no redirect")
-    end
-  end
-
-  describe "Given a controller spec running in #{mode} mode" do
-    example_group = describe "A controller spec"
-    # , :type => :controller do
-    # integrate_views if mode == 'integration'
-    it "a spec in a context without controller_name set should fail with a useful warning" do
-      pending("need a new way to deal with examples that should_raise")
-    # ,
-    #   :should_raise => [
-    #     Spec::Expectations::ExpectationNotMetError,
-    #     /You have to declare the controller name in controller specs/
-    #   ] do
-    end
-  end
-
-end
-
-describe ControllerSpecController, :type => :controller do
-  it "should not require naming the controller if describe is passed a type" do
-  end
-end
-
-module Spec
-  module Rails
-    module Example
-      describe ControllerExampleGroup do
-        it "should clear its name from the description" do
-          group = describe("foo", :type => :controller) do
-            $nested_group = describe("bar") do
-            end
-          end
-          group.description.to_s.should == "foo"
-          $nested_group.description.to_s.should == "foo bar"
-        end
-      end
-    end
-  end
-end

data/rails_plugins/rspec_on_rails/spec/rails/example/example_group_factory_spec.rb

@@ -1,112 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-module Spec
-  module Example
-    describe ExampleGroupFactory do
-      it "should return a ModelExampleGroup when given :type => :model" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :type => :model
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ModelExampleGroup
-      end
-
-      it "should return a ModelExampleGroup when given :spec_path => '/blah/spec/models/'" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '/blah/spec/models/blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ModelExampleGroup
-      end
-
-      it "should return a ModelExampleGroup when given :spec_path => '\\blah\\spec\\models\\' (windows format)" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '\\blah\\spec\\models\\blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ModelExampleGroup
-      end
-
-      it "should return a RailsExampleGroup when given :spec_path => '/blah/spec/foo/' (anything other than controllers, views and helpers)" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '/blah/spec/foo/blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::RailsExampleGroup
-      end
-
-      it "should return a RailsExampleGroup when given :spec_path => '\\blah\\spec\\foo\\' (windows format)  (anything other than controllers, views and helpers)" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '\\blah\\spec\\foo\\blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::RailsExampleGroup
-      end
-
-      it "should return a ViewExampleGroup when given :type => :model" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :type => :view
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ViewExampleGroup
-      end
-
-      it "should return a ViewExampleGroup when given :spec_path => '/blah/spec/views/'" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '/blah/spec/views/blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ViewExampleGroup
-      end
-
-      it "should return a ModelExampleGroup when given :spec_path => '\\blah\\spec\\views\\' (windows format)" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '\\blah\\spec\\views\\blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ViewExampleGroup
-      end
-
-      it "should return a HelperExampleGroup when given :type => :helper" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :type => :helper
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::HelperExampleGroup
-      end
-
-      it "should return a HelperExampleGroup when given :spec_path => '/blah/spec/helpers/'" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '/blah/spec/helpers/blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::HelperExampleGroup
-      end
-
-      it "should return a ModelExampleGroup when given :spec_path => '\\blah\\spec\\helpers\\' (windows format)" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '\\blah\\spec\\helpers\\blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::HelperExampleGroup
-      end
-
-      it "should return a ControllerExampleGroup when given :type => :controller" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :type => :controller
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ControllerExampleGroup
-      end
-
-      it "should return a ControllerExampleGroup when given :spec_path => '/blah/spec/controllers/'" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '/blah/spec/controllers/blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ControllerExampleGroup
-      end
-
-      it "should return a ModelExampleGroup when given :spec_path => '\\blah\\spec\\controllers\\' (windows format)" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '\\blah\\spec\\controllers\\blah.rb'
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ControllerExampleGroup
-      end
-
-      it "should favor the :type over the :spec_path" do
-        example_group = Spec::Example::ExampleGroupFactory.create_example_group(
-          "name", :spec_path => '/blah/spec/models/blah.rb', :type => :controller
-        ) {}
-        example_group.superclass.should == Spec::Rails::Example::ControllerExampleGroup
-      end
-    end
-  end
-end

data/rails_plugins/rspec_on_rails/spec/rails/example/helper_spec_spec.rb

@@ -1,118 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-Spec::Runner.configuration.global_fixtures = :people
-
-describe ExplicitHelper, :type => :helper do
-  it "should not require naming the helper if describe is passed a type" do
-    method_in_explicit_helper.should match(/text from a method/)
-  end
-end
-
-module Spec
-  module Rails
-    module Example
-      describe HelperExampleGroup, :type => :helper do
-        helper_name :explicit
-
-        it "should have direct access to methods defined in helpers" do
-          method_in_explicit_helper.should =~ /text from a method/
-        end
-
-        it "should have access to named routes" do
-          rspec_on_rails_specs_url.should == "http://test.host/rspec_on_rails_specs"
-          rspec_on_rails_specs_path.should == "/rspec_on_rails_specs"
-        end
-
-        it "should fail if the helper method deson't exist" do
-          lambda { non_existant_helper_method }.should raise_error(NameError)
-        end
-      end
-
-
-      describe HelperExampleGroup, "#eval_erb", :type => :helper do
-        helper_name :explicit
-
-        it "should support methods that accept blocks" do
-          eval_erb("<% prepend 'foo' do %>bar<% end %>").should == "foobar"
-        end
-      end
-
-      describe HelperExampleGroup, ".fixtures", :type => :helper do
-        helper_name :explicit
-        fixtures :animals
-
-        it "should load fixtures" do
-          pig = animals(:pig)
-          pig.class.should == Animal
-        end
-
-        it "should load global fixtures" do
-          lachie = people(:lachie)
-          lachie.class.should == Person
-        end
-      end
-
-      describe HelperExampleGroup, "included modules", :type => :helper do
-        helpers = [
-          ActionView::Helpers::ActiveRecordHelper,
-          ActionView::Helpers::AssetTagHelper,
-          ActionView::Helpers::BenchmarkHelper,
-          ActionView::Helpers::CacheHelper,
-          ActionView::Helpers::CaptureHelper,
-          ActionView::Helpers::DateHelper,
-          ActionView::Helpers::DebugHelper,
-          ActionView::Helpers::FormHelper,
-          ActionView::Helpers::FormOptionsHelper,
-          ActionView::Helpers::FormTagHelper,
-          ActionView::Helpers::JavaScriptHelper,
-          ActionView::Helpers::NumberHelper,
-          ActionView::Helpers::PrototypeHelper,
-          ActionView::Helpers::ScriptaculousHelper,
-          ActionView::Helpers::TagHelper,
-          ActionView::Helpers::TextHelper,
-          ActionView::Helpers::UrlHelper
-        ]
-        helpers << ActionView::Helpers::PaginationHelper rescue nil       #removed for 2.0
-        helpers << ActionView::Helpers::JavaScriptMacrosHelper rescue nil #removed for 2.0
-        helpers.each do |helper_module|
-          it "should include #{helper_module}" do
-            self.class.ancestors.should include(helper_module)
-          end
-        end
-      end
-
-      # TODO: BT - Helper Examples should proxy method_missing to a Rails View instance.
-      # When that is done, remove this method
-      describe HelperExampleGroup, "#protect_against_forgery?", :type => :helper do
-        it "should return false" do
-          protect_against_forgery?.should be_false
-        end
-      end
-    end
-  end
-end
-
-module Bug11223
-  # see http://rubyforge.org/tracker/index.php?func=detail&aid=11223&group_id=797&atid=3149
-  describe 'Accessing flash from helper spec', :type => :helper do
-    it 'should not raise an error' do
-      lambda { flash['test'] }.should_not raise_error
-    end
-  end
-end
-
-module Spec
-  module Rails
-    module Example
-      describe HelperExampleGroup do
-        it "should clear its name from the description" do
-          group = describe("foo", :type => :helper) do
-            $nested_group = describe("bar") do
-            end
-          end
-          group.description.to_s.should == "foo"
-          $nested_group.description.to_s.should == "foo bar"
-        end
-      end
-    end
-  end
-end

data/rails_plugins/rspec_on_rails/spec/rails/example/ivar_proxy_spec.rb

@@ -1,64 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe "IvarProxy setup", :shared => true do
-  before do
-    @object = Object.new
-    @proxy = Spec::Rails::Example::IvarProxy.new(@object)
-  end
-end
-
-describe "IvarProxy" do
-  it_should_behave_like "IvarProxy setup"
-
-  it "has [] accessor" do
-    @proxy['foo'] = 'bar'
-    @object.instance_variable_get(:@foo).should == 'bar'
-    @proxy['foo'].should == 'bar'
-  end
-
-  it "iterates through each element like a Hash" do
-    values = {
-      'foo' => 1,
-      'bar' => 2,
-      'baz' => 3
-    }
-    @proxy['foo'] = values['foo']
-    @proxy['bar'] = values['bar']
-    @proxy['baz'] = values['baz']
-
-    @proxy.each do |key, value|
-      key.should == key
-      value.should == values[key]
-    end
-  end
-
-  it "detects the presence of a key" do
-    @proxy['foo'] = 'bar'
-    @proxy.has_key?('foo').should == true
-    @proxy.has_key?('bar').should == false
-  end
-end
-
-describe "IvarProxy", "#delete" do
-  it_should_behave_like "IvarProxy setup"
-
-  it "deletes the element with key" do
-    @proxy['foo'] = 'bar'
-    @proxy.delete('foo').should == 'bar'
-    @proxy['foo'].should be_nil
-  end
-
-  it "deletes nil instance variables" do
-    @proxy['foo'] = nil
-    @object.instance_variables.should include("@foo")
-    @proxy.delete('foo').should == nil
-    @proxy['foo'].should be_nil
-    @object.instance_variables.should_not include("@foo")
-  end
-
-  it "returns nil when key does not exist" do
-    @proxy['foo'].should be_nil
-    @proxy.delete('foo').should == nil
-    @proxy['foo'].should be_nil
-  end
-end