thorero 0.9.4.4 → 0.9.4.5

data/spec/public/test/route_matchers_spec.rb

@@ -0,0 +1,162 @@
+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
+      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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,183 @@
+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

data/spec/spec_helper.rb

@@ -0,0 +1,68 @@
+$TESTING=true
+require "rubygems"
+require "spec"
+require File.join(File.dirname(__FILE__), "..", "lib", "merb-core")
+
+Merb.start :environment => 'test', :adapter => 'runner'
+
+# -- Global custom matchers --
+
+# A better +be_kind_of+ with more informative error messages.
+#
+# The default +be_kind_of+ just says
+#
+#   "expected to return true but got false"
+#
+# This one says
+#
+#   "expected File but got Tempfile"
+
+module Merb
+  module Test
+    module RspecMatchers
+      class BeKindOf
+        def initialize(expected) # + args
+          @expected = expected
+        end
+
+        def matches?(target)
+          @target = target
+          @target.kind_of?(@expected)
+        end
+
+        def failure_message
+          "expected #{@expected} but got #{@target.class}"
+        end
+
+        def negative_failure_message
+          "expected #{@expected} to not be #{@target.class}"
+        end
+
+        def description
+          "be_kind_of #{@target}"
+        end
+      end
+
+      def be_kind_of(expected) # + args
+        BeKindOf.new(expected)
+      end
+    end
+
+    module Helper
+      def running(&blk) blk; end
+
+      def executing(&blk) blk; end
+
+      def doing(&blk) blk; end
+
+      def calling(&blk) blk; end
+    end
+  end
+end
+
+
+Spec::Runner.configure do |config|
+  config.include Merb::Test::Helper
+  config.include Merb::Test::RspecMatchers
+  config.include Merb::Test::RequestHelper
+end