merb-core 0.9.7 → 0.9.8

data/spec/public/test/route_helper_spec.rb

@@ -1,78 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
-
-class TestController < Merb::Controller
-  def get(id = nil); end
-  def post; end
-end
-
-describe Merb::Test::RouteHelper do
-  before(:each) do
-    Merb::Router.prepare do |r|
-      r.match("/").defer_to do |request, params|
-        { :controller => 'test_controller', :action => request.raw_post } unless request.raw_post.blank?
-      end
-      r.match("/", :method => :get).to(:controller => "test_controller", :action => "get").name(:getter)
-      r.match("/", :method => :post).to(:controller => "test_controller", :action => "post")
-      r.match("/:id").to(:controller => "test_controller", :action => "get").name(:with_id)
-    end
-  end
-  
-  describe "#url" do
-    it "should use Merb::Router" do
-      url(:getter).should == "/"
-    end
-    
-    it "should work with a model as the parameter" do
-      model = mock(:model)
-      model.stub!(:id).and_return("123")
-      url(:with_id, model).should == "/123"
-    end
-    
-    it "should work with a parameters hash" do
-      url(:with_id, :id => 123).should == "/123"
-    end
-    
-    it "should turn extra hash items into query params" do
-      generated_url = url(:getter, :id => 123, :color => 'red', :size => 'large')
-      lambda {
-        generated_url.match(/\bid=123\b/) &&
-        generated_url.match(/\bsize=large\b/) &&
-        generated_url.match(/\bcolor=red\b/)
-      }.call.should_not be_nil
-    end
-    
-    it "should remove items with nil values from query params" do
-      url(:getter, :color => nil, :size => 'large').should == "/?size=large"
-    end
-    
-    it "should remove items with nil values from query params when named route isn't specified" do
-      url(:controller => 'cont', :action => 'act', :color => nil, :size => 'large').should == "/cont/act?size=large"
-    end
-  end
-  
-  describe "#request_to" do
-    it "should GET if no method is given" do
-      request_to("/")[:action].should == "get"
-    end
-    
-    it "should return a hash" do
-      Hash.should === request_to("/")
-    end
-    
-    it "should contain the controller in the result" do
-      request_to("/")[:controller].should == "test_controller"
-    end
-    
-    it "should contain the action in the result" do
-      request_to("/")[:action].should == "get"
-    end
-    
-    it "should contain any parameters in the result" do
-      request_to("/123")[:id].should == "123"
-    end
-
-    it "should play nice with raw_post in deferred routing" do
-      request_to("/", :post, {:post_body => 'deferred'})[:action].should == 'deferred'
-    end
-  end
-end

data/spec/public/test/route_matchers_spec.rb

@@ -1,166 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
-
-Merb.start :environment => 'test', :log_level => :fatal
-
-class TestController < Merb::Controller
-  def get(id = nil); end
-  def post(version = nil); end
-end
-
-class IDish
-  attr_accessor :id
-  alias_method :to_param, :id
-
-  def initialize(id)
-    @id = id
-  end
-end
-
-describe Merb::Test::Rspec::RouteMatchers do
-  include Merb::Test::RouteHelper
-
-  before(:each) do
-    Merb::Router.prepare do |r|
-      r.match(%r"/v(\d+\.\d+)", :method => :post).to(:controller => "test_controller", :action => "post", :version => "[1]")
-      r.match("/", :method => :get).to(:controller => "test_controller", :action => "get").name(:getter)
-      r.match("/", :method => :post).to(:controller => "test_controller", :action => "post")
-      r.match("/:id").to(:controller => "test_controller", :action => "get").name(:with_id)
-    end
-  end
-
-  describe "#route_to" do
-    it "should work with the request_to helper" do
-      request_to("/", :get).should route_to(TestController, :get)
-      request_to("/", :post).should_not route_to(TestController, :get)
-    end
-
-    it "should work with the url helper and ParamMatcher" do
-      idish = IDish.new(rand(1000).to_s)
-      
-      request_to(url(:with_id, idish)).should route_to(TestController, :get).with(idish)
-    end
-
-    it "should work with a negative ParamMatcher" do
-      request_to(url(:with_id, :id => 100)).should_not route_to(TestController, :get).with(:id => 1)
-    end
-
-    it "should work with a route containing a regexp" do
-      request_to("/v1.2", :post).should route_to(TestController, :post).with(:version => "1.2")
-      request_to("/v1.0", :post).should_not route_to(TestController, :post).with(:version => "3.14")
-    end
-  end
-
-  module Merb::Test::Rspec::RouteMatchers
-
-    describe RouteToMatcher do
-
-      it "should work with snake cased controllers" do
-        RouteToMatcher.new(TestController, :get).matches?(:controller => "test_controller", :action => "get").should be_true
-      end
-
-      it "should work with camel cased controllers" do
-        RouteToMatcher.new(TestController, :get).matches?(:controller => "TestController", :action => "get").should be_true
-      end
-
-      it "should work with symbol or string controller name" do
-        RouteToMatcher.new(TestController, :get).matches?(:controller => "test_controller", :action => "get").should be_true
-        RouteToMatcher.new(TestController, :get).matches?(:controller => :test_controller, :action => :get)
-      end
-
-      it "should not pass if the controllers do not match" do
-        RouteToMatcher.new(TestController, :get).matches?(:controller => "other_controller", :action => "get").should be_false
-      end
-
-      it "should not pass if the actions do not match" do
-        RouteToMatcher.new(TestController, :get).matches?(:controller => "test_controller", :action => "post").should be_false
-      end
-
-      it "should not pass if the parameters do not the ParameterMatcher" do
-        route_matcher = RouteToMatcher.new(TestController, :get)
-        route_matcher.with(:id => "123")
-
-        route_matcher.matches?(:controller => "test_case", :action => "get", :id => "456").should be_false
-      end
-
-      describe "#with" do
-        it "should add a ParameterMatcher" do
-          ParameterMatcher.should_receive(:new).with(:id => "123")
-
-          route_matcher = RouteToMatcher.new(TestController, :get)
-          route_matcher.with(:id => "123")
-        end
-
-        it "should work with an empty expectation" do
-          ParameterMatcher.new({}).matches?(:param => "abc").should be_false
-        end
-      end
-
-      describe "#failure_message" do
-        it "should include the expected controller and action" do
-          matcher = RouteToMatcher.new(TestController, :any_action)
-          matcher.matches?(:controller => "target_controller", :action => "target_action")
-          matcher.failure_message.should include("TestController#any_action")
-        end
-
-        it "should include the target controller and action in camel case" do
-          matcher = RouteToMatcher.new(TestController, :any_action)
-          matcher.matches?(:controller => "target_controller", :action => "target_action")
-          matcher.failure_message.should include("TargetController#target_action")
-        end
-
-        it "should include the expected parameters" do
-          expected_parameters = {:id => '123', :page => '2'}
-          matcher = RouteToMatcher.new(TestController, :any_action)
-          matcher.with(expected_parameters)
-          matcher.matches?(:controller => "target_controller", :action => "target_action")
-          matcher.failure_message.should include(expected_parameters.inspect)
-        end
-
-        it "should include the actual paramters" do
-          expected_parameters, actual_parameters = {:id => '123', :page => '2'}, {:id => '2', :page => '321'}
-          matcher = RouteToMatcher.new(TestController, :any_action)
-          matcher.with(expected_parameters)
-          matcher.matches?(actual_parameters.merge(:controller => "test_controller", :action => "any_action"))
-          matcher.failure_message.should include(actual_parameters.inspect)
-        end
-      end
-
-      describe "#negative_failure_message" do
-        it "should include the expected controller and action" do
-          RouteToMatcher.new(TestController, :any_action).negative_failure_message.should include("TestController#any_action")
-        end
-      end
-    end
-
-    describe ParameterMatcher do
-      it "should work with a Hash as the parameter argument" do
-        ParameterMatcher.new(:param => "abc").matches?(:param => "abc").should be_true
-      end
-
-      it "should work with an object as the parameter argument" do
-        ParameterMatcher.new(IDish.new(1234)).matches?(:id => 1234).should be_true
-      end
-
-      describe "#failure_message" do
-        it "should include the expected parameters hash" do
-          parameter_hash = {:parent_id => "123", :child_id => "abc"}
-          ParameterMatcher.new(parameter_hash).failure_message.should include(parameter_hash.inspect)
-        end
-
-        it "should include the actual parameters hash" do
-          parameter_hash = {:parent_id => "123", :child_id => "abc"}
-          matcher = ParameterMatcher.new(:id => 123)
-          matcher.matches?(parameter_hash)
-          matcher.failure_message.should include(parameter_hash.inspect)
-        end
-      end
-
-      describe "#negative_failure_message" do
-        it "should include the expected parameters hash" do
-          parameter_hash = {:parent_id => "123", :child_id => "abc"}
-          ParameterMatcher.new(parameter_hash).negative_failure_message.should include(parameter_hash.inspect)
-        end
-      end
-    end
-  end
-end

data/spec/public/test/view_helper_spec.rb

@@ -1,96 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
-
-describe Merb::Test::ViewHelper do
-  before(:each) do
-    @output = Merb::Test::ViewHelper::DocumentOutput.new(test_response)
-  end
-  
-  describe "#tag" do
-    it "should return the inner content of the first tag found by the css query" do
-      tag(:li).should == "item 1"
-    end
-  end
-  
-  describe "#tags" do
-    it "should return an array of tag contents for all tags found by the css query" do
-      tags(:li).should include("item 1", "item 2", "item 3")
-    end
-  end
-  
-  describe "#element" do
-    it "should return a raw Hpricot::Elem object for the first result found by the query" do
-      Hpricot::Elem.should === element(:body)
-    end
-  end
-  
-  describe "#elements" do
-    it "should return an array of Hpricot::Elem objects for the results found by the query" do
-      elements("li, ul").each{|ele| Hpricot::Elem.should === ele}
-    end
-  end
-  
-  describe "#have_tag" do
-    it "should work without options hash" do
-      have_tag(:html)
-    end
-    
-    it "should work with options hash" do
-      have_tag(:html, {})
-    end
-  end
-  
-  describe "#get_elements" do
-    it "should return an array of Hpricot::Elem objects for the results found by the query containing the filter string" do
-      get_elements(:li, "item").size.should == 3
-      get_elements(:li, "item 2").size.should == 1
-    end
-    
-    it "should return an array of Hpricot::Elem objects for the results found by the query matching the filter regexp" do
-      get_elements(:li, /^item \d$/).size.should == 3
-      get_elements(:li, /^item (1|2)$/).size.should == 2
-    end
-  end
-  
-  it "should raise an error if the ouput is not specified and cannot be found" do
-    @output, @response_output, @controller = nil
-    
-    lambda { tag("div") }.should raise_error("The response output was not in its usual places, please provide the output")
-  end
-  
-  it "should use @output if no output parameter is supplied" do
-    @output.should_receive(:content_for)
-    
-    tag(:div)
-  end
-  
-  it "should use @output_response if no output parameter is supplied and @output does not contain output" do
-    @output = nil
-    @response_output = test_response
-    
-    tag(:div)
-  end
-  
-  it "should use @controller.body if no output parameter is supplied and both @output and @response_output do not contain output" do
-    @output, @response_output = nil
-    @controller = mock(:controller)
-    @controller.should_receive(:nil?).and_return false
-    @controller.should_receive(:body).any_number_of_times.and_return test_response
-    
-    tag(:div)
-  end
-  
-  def test_response
-    <<-EOR
-<html>
-  <body>
-    <div>Hello, World!</div>
-    <ul>
-      <li>item 1</li>
-      <li>item 2</li>
-      <li>item 3</li>
-    </ul
-  </body>
-</html>
-EOR
-  end
-end

data/spec/public/test/view_matchers_spec.rb

@@ -1,183 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
-require "merb-core/test"
-
-Merb.start :environment => 'test', :log_level => :fatal
-
-describe Merb::Test::Rspec::ViewMatchers do
-  include Merb::Test::ViewHelper
-  
-  before(:each) do
-    @body = <<-EOF
-    <div id='main'>
-      <div class='inner'>hello, world!</div>
-    </div>
-    EOF
-  end
-  
-  describe "#match_tag" do
-    it "should work with a HasContent matcher in the block" do
-      @body.should have_tag(:div) {|d| d.should_not contain("merb")}
-    end
-    
-    it "should work with a 'with_tag' chain" do
-      @body.should have_tag(:div, :id => :main).with_tag(:div, :class => 'inner')
-    end
-    
-    it "should work with a block before a with_tag" do
-      @body.should have_tag(:div, :id => :main) {|d| d.should_not contain("merb")}.with_tag(:div, :class => 'inner')
-    end
-  end
-
-  module Merb::Test::Rspec::ViewMatchers
-  
-    describe HasTag do
-      describe "#matches?" do
-        before(:each) do
-          @document = stub(:document)
-          Hpricot.should_receive(:parse).and_return @document
-        end
-      
-        it "should should pass all found elements to the block" do
-          @block_called = false
-        
-          @document.should_receive(:search).and_return [""]
-          HasTag.new("tag").matches?("") {|e| @block_called = true}
-        
-          @block_called.should be_true
-        end
-      
-        it "should not intercept any errors raised in the block" do
-          @document.should_receive(:search).and_return [""]
-          lambda {
-            HasTag.new("tag").matches?("") {|e| true.should be_false }
-          }.should raise_error(Spec::Expectations::ExpectationNotMetError)
-        end
-      end
-    
-      describe "#with_tag" do
-        it "should set @inner_tag" do
-          outer = HasTag.new("outer")
-          inner = outer.with_tag("inner")
-        
-          outer.selector.should include(inner.selector)
-        end
-      end
-    
-      describe "#selector" do
-        it "should always start with \/\/" do
-          HasTag.new("tag").selector.should =~ /^\/\//
-        end
-      
-        it "should use @tag for the element" do
-          HasTag.new("tag").selector.should include("tag")
-        end
-      
-        it "should use dot notation for the class" do
-          HasTag.new("tag", :class => "class").selector.should include("tag.class")
-        end
-      
-        it "should use pound(#) notation for the id" do
-          HasTag.new("tag", :id => "id").selector.should include("tag#id")
-        end
-      
-        it "should include any custom attributes" do
-          HasTag.new("tag", :random => :attribute).selector.should include("[@random=\"attribute\"]")
-        end
-      
-        it "should not include the class as a custom attribute" do
-          HasTag.new("tag", :class => :my_class, :rand => :attr).selector.should_not include("[@class=\"my_class\"]")
-        end
-      
-        it "should not include the id as a custom attribute" do
-          HasTag.new("tag", :id => :my_id, :rand => :attr).selector.should_not include("[@id=\"my_id\"]")
-        end
-      end
-    
-      describe "#failure_message" do
-        it "should include the tag name" do
-          HasTag.new("anytag").failure_message.should include("<anytag")
-        end
-      
-        it "should include the tag's id" do
-          HasTag.new("div", :id => :spacer).failure_message.should include("<div id=\"spacer\"")
-        end
-      
-        it "should include the tag's class" do
-          HasTag.new("div", :class => :header).failure_message.should include("<div class=\"header\"")
-        end
-      
-        it "should include the tag's custom attributes" do
-          HasTag.new("h1", :attr => :val, :foo => :bar).failure_message.should include("attr=\"val\"")
-          HasTag.new("h1", :attr => :val, :foo => :bar).failure_message.should include("foo=\"bar\"")
-        end
-      end
-    
-      describe "id, class, and attributes for error messages" do
-        it "should start with a space for a class, id, or custom attribute" do
-          HasTag.new("tag", :id => "identifier").id_for_error.should =~ /^ /
-          HasTag.new("tag", :class => "classifier").class_for_error.should =~ /^ /
-          HasTag.new("tag", :rand => "attr").attributes_for_error.should =~ /^ /
-        end
-      
-        it "should have 'class=\"classifier\"' in class_for_error" do
-          HasTag.new("tag", :class => "classifier").class_for_error.should include("class=\"classifier\"")
-        end
-      
-        it "should have 'id=\"identifier\" in id_for_error" do
-          HasTag.new("tag", :id => "identifier").id_for_error.should include("id=\"identifier\"")
-        end
-      end
-    end
-    
-    describe HasContent do
-      before(:each) do
-        @element = stub(:element)
-        @element.stub!(:inner_text).and_return <<-EOF
-          <div id='main'>
-            <div class='inner'>hello, world!</div>
-          </div>
-        EOF
-        
-        @element.stub!(:contains?)
-        @element.stub!(:matches?)
-      end
-      
-      describe "#matches?" do
-        it "should call element#contains? when the argument is a string" do
-          @element.should_receive(:contains?)
-          
-          HasContent.new("hello, world!").matches?(@element)
-        end
-        
-        it "should call element#matches? when the argument is a regular expression" do
-          @element.should_receive(:matches?)
-          
-          HasContent.new(/hello, world/).matches?(@element)
-        end
-      end
-    
-      describe "#failure_message" do
-        it "should include the content string" do
-          hc = HasContent.new("hello, world!")
-          hc.matches?(@element)
-          
-          hc.failure_message.should include("\"hello, world!\"")
-        end
-        
-        it "should include the content regular expresson" do
-          hc = HasContent.new(/hello,\sworld!/)
-          hc.matches?(@element)
-          
-          hc.failure_message.should include("/hello,\\sworld!/")
-        end
-        
-        it "should include the element's inner content" do
-          hc = HasContent.new(/hello,\sworld!/)
-          hc.matches?(@element)
-          
-          hc.failure_message.should include(@element.inner_text)
-        end
-      end
-    end
-  end
-end