thorero 0.9.4.4 → 0.9.4.5

data/spec/public/router/special_spec.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "Regex-based routes" do
+
+  it "should process a simple regex" do
+    prepare_route(%r[^/foos?/(bar|baz)/:id], :controller => "foo", :action => "[1]", :id => ":id")
+    route_to("/foo/bar/baz").should have_route(:controller => "foo", :action => "bar", :id => "baz")
+    route_to("/foos/baz/bam").should have_route(:controller => "foo", :action => "baz", :id => "bam")
+  end
+
+  it "should support inbound user agents" do
+    Merb::Router.prepare do |r|
+      r.match(%r[^/foo/(.+)], :user_agent => /(MSIE|Gecko)/).
+        to(:controller => "foo", :title => "[1]", :action => "show", :agent => ":user_agent[1]")
+    end
+    route_to("/foo/bar", :user_agent => /MSIE/).should have_route(
+      :controller => "foo", :action => "show", :title => "bar", :agent => "MSIE"
+    )
+  end
+
+end
+
+describe "Routes that are restricted based on incoming params" do
+
+  it "should allow you to restrict routes to POST requests" do
+    Merb::Router.prepare do |r|
+      r.match("/:controller/create/:id", :method => :post).
+        to(:action => "create")
+    end
+    route_to("/foo/create/12", :method => "post").should have_route(
+      :controller => "foo", :action => "create", :id => "12"
+    )
+
+    route_to("/foo/create/12", :method => "get").should_not have_route(
+      :controller => "foo", :action => "create", :id => "12"
+    )
+  end
+
+  it "should allow you to restrict routes based on protocol" do
+    Merb::Router.prepare do |r|
+      r.match(:protocol => "http://").to(:controller => "foo", :action => "bar")
+      r.default_routes
+    end
+    route_to("/foo/bar").should have_route(:controller => "foo", :action => "bar")
+    route_to("/boo/hoo", :protocol => "https://").should have_route(:controller => "boo", :action => "hoo")
+  end
+
+  it "does not require explicit specifying of params" do
+    Merb::Router.prepare do |r|
+      r.match!("/fb/:callback_path/:controller/:action")
+    end
+
+    route_to("/fb/callybacky/products/search").should have_route(
+      :controller => "products", :action => "search", :callback_path => "callybacky"
+    )
+    route_to("/fb/ping/products/search").should have_route(
+      :controller => "products", :action => "search", :callback_path => "ping"
+    )
+  end
+
+end

data/spec/public/router/string_spec.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe "A plain route with no variables" do
+  
+  it "should return the parameters passed to #to" do
+    prepare_route("/info", :controller => "info", :action => "foo")
+    route_to("/info").should have_route(:controller => "info", :action => "foo", :id => nil)
+  end
+    
+end
+
+describe "A route with variables specified as :foo/:bar" do
+  
+  it "should work with :controller/:action/:id" do
+    prepare_route("/foo/:action/:id", :controller => "foobar")
+    route_to("/foo/bar/baz").should have_route(:controller => "foobar", :action => "bar", :id => "baz")
+  end
+  
+  it "should work with :foo/:bar/:baz to :controller => ':foo/:bar'" do
+    prepare_route("/:foo/:bar/:baz/:id", :controller => ":foo/:bar", :action => ":baz")
+    route_to("/one/two/three/4").should have_route(:controller => "one/two", :action => "three", :id => "4")
+  end
+  
+end
+
+describe "A route containing block matchers" do
+  
+  it "should support block matchers as a path namespace" do
+    Merb::Router.prepare do |r|
+      r.match("/foo") do |path|
+        path.match("/bar/:id").to(:controller => "foo/bar", :action => "bar")
+      end
+    end
+    route_to("/foo/bar/1").should have_route(:controller => "foo/bar", :action => "bar", :id => "1")
+  end
+  
+  it "should still support :variables in the to route from any level" do
+    Merb::Router.prepare do |r|
+      r.match("/foo/:bar") do |path|
+        path.match("/:baz/:id").to(:controller => "foo", :action => ":id", :id => ":bar/:baz")
+      end
+    end
+    route_to("/foo/hello/goodbye/zoo").should have_route(:controller => "foo", :action => "zoo", :id => "hello/goodbye")
+  end
+  
+end
+
+describe "A route containing block matchers for the 'to' section" do
+  
+  it "should point a bunch of 'from' segments to the same 'to'" do
+    Merb::Router.prepare do |r|
+      r.to(:controller => "foo") do |a|
+        a.match("/hello/:action/:id").to(:tag => ":id")
+      end
+    end
+    route_to("/hello/goodbye/tagging").should have_route(
+      :controller => "foo", :action => "goodbye", :id => "tagging", :tag => "tagging"
+    )
+  end
+  
+end

data/spec/public/template/template_spec.rb

@@ -0,0 +1,104 @@
+# ==== Public Template API
+# Merb::Template.register_extensions(engine<Class>, extenstions<Array[String]>)
+#
+# ==== Semipublic Template API
+# Merb::Template.engine_for(path<String>)
+# Merb::Template.template_name(path<String>)
+# Merb::Template.inline_template(path<String>, mod<Module>)
+#
+# ==== Requirements for a new Template Engine
+# A Template Engine must have at least a single class method called compile_template
+# with the following parameters:
+# * path<String>:: the full path to the template being compiled
+# * name<String>:: the name of the method that will be inlined
+# * mod<Module>:: the module that the method will be inlined into
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
+
+# A small structure to hold the templates so we can test the templating system in isolation
+# from the framework
+
+module Merb::Test::Fixtures
+  # This is a fake templating engine that just copies the text of the template
+  # exactly from the file
+  
+  class MyTemplateEngine
+    
+    def self.compile_template(io, name, mod)
+      text = io.read
+      table = { "\r"=>"\\r", "\n"=>"\\n", "\t"=>"\\t", '"'=>'\\"', "\\"=>"\\\\" }      
+      text = (text.split("\n").map {|x| '"' + (x.gsub(/[\r\n\t"\\]/) { |m| table[m] }) + '"'}).join(" +\n")
+      mod.class_eval <<-EOS, File.expand_path(io.path)
+        def #{name}
+          #{text}
+        end
+      EOS
+    end
+    
+    module Mixin
+    end
+  end
+
+  module MyHelpers
+  end
+
+  class Environment
+    include MyHelpers
+  end
+end
+
+describe Merb::Template do
+  
+  # @public
+  it "should accept template-type registrations via #register_extensions" do
+    Merb::Template.register_extensions(Merb::Test::Fixtures::MyTemplateEngine, %w[myt])
+    Merb::Template.engine_for("foo.myt").should == Merb::Test::Fixtures::MyTemplateEngine
+    Merb::Template.template_extensions.should include("myt")
+  end
+  
+  # @semipublic
+  
+  def rendering_template(template_path)
+    Merb::Template.inline_template(File.open(template_path), Merb::Test::Fixtures::MyHelpers)
+    Merb::Test::Fixtures::Environment.new.
+      send(Merb::Template.template_name(template_path))  
+  end
+  alias_method :render_template, :rendering_template
+  
+  it "should compile and inline templates via #inline methods for custom languages" do
+    template_path = File.dirname(__FILE__) / "templates" / "template.html.myt"
+    rendering_template(template_path).should == "Hello world!"
+  end
+  
+  it "should compile and inline templates via #inline_template for erubis" do
+    template_path = File.dirname(__FILE__) / "templates" / "template.html.erb"
+    rendering_template(template_path).should == "Hello world!"
+  end
+  
+  it "should compile and inline templates that comes through via VirtualFile" do
+    Merb::Template.inline_template(VirtualFile.new("Hello", 
+      File.dirname(__FILE__) / "templates" / "template.html.erb"), 
+      Merb::Test::Fixtures::MyHelpers)
+      
+    res = Merb::Test::Fixtures::Environment.new.
+      send(Merb::Template.template_name(File.dirname(__FILE__) / "templates" / "template.html.erb"))
+      
+    res.should == "Hello"
+  end
+  
+  it "should know how to correctly report errors" do
+    template_path = File.dirname(__FILE__) / "templates" / "error.html.erb"
+    running { render_template(template_path) }.should raise_error(NameError, /`foo'/)
+    begin
+      render_template(template_path)
+    rescue Exception => e
+      e.backtrace.first.match(/\/([^:\/]*:\d*)/)[1].should == "error.html.erb:2"
+    end
+  end
+  
+  it "should find the full template name for a path via #template_for" do
+    template_path = File.dirname(__FILE__) / "templates" / "template.html.erb"
+    name = Merb::Template.inline_template(File.open(template_path), Merb::Test::Fixtures::MyHelpers)
+    Merb::Test::Fixtures::Environment.new.should respond_to(name)
+  end
+  
+end

data/spec/public/template/templates/error.html.erb

@@ -0,0 +1,2 @@
+Hello
+<%= foo %>

data/spec/public/template/templates/template.html.erb

@@ -0,0 +1 @@
+Hello world!

data/spec/public/template/templates/template.html.myt

@@ -0,0 +1 @@
+Hello world!

data/spec/public/test/controller_matchers_spec.rb

@@ -0,0 +1,402 @@
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
+
+Merb.start :environment => 'test', :log_level => :fatal
+
+class TestController < Merb::Controller
+  attr_accessor :redirect_to
+  def redirect_action; redirect(@redirect_to || "/"); end
+  def success_action; end
+  def missing_action; render("i can has errorz", :status => 404); end
+end
+
+describe Merb::Test::Rspec::ControllerMatchers do
+  include Merb::Test::ControllerHelper
+  before(:each) do
+    Merb::Router.prepare do |r|
+      r.match("/redirect").to(:controller => "test_controller", :action => "redirect_action")
+      r.match("/success").to(:controller => "test_controller", :action => "success_action")
+      r.match("/missing").to(:controller => "test_controller", :action => "missing_action")
+    end
+  end
+  
+  describe "#redirect" do
+    it "should work with the result of a dispatch_to helper call" do
+      dispatch_to(TestController, :redirect_action).should redirect
+    end
+    
+    it "should work with the result of a get helper call" do
+      get("/redirect").should redirect
+    end
+    
+    it "should work with a redirection code" do
+      dispatch_to(TestController, :redirect_action).status.should redirect
+    end
+  end
+  
+  describe "#redirect_to" do
+    it "should work with the result of a dispatch_to helper call" do
+      dispatch_to(TestController, :redirect_action).should redirect_to("/")
+      dispatch_to(TestController, :redirect_action){ |controller| controller.redirect_to = "http://example.com/" }.should redirect_to("http://example.com/")
+    end
+    
+    it "should work with the result of a get helper call" do
+      get("/redirect"){|controller| controller.redirect_to = "http://example.com/" }.should redirect_to("http://example.com/")
+    end
+  end
+  
+  describe "#respond_successfully" do
+    it "should work with the result of a dispatch_to helper call" do
+      dispatch_to(TestController, :success_action).should respond_successfully
+    end
+    
+    it "should work with the result of a get helper call" do
+      get("/success").should respond_successfully
+    end
+    
+    it "should work with a redirection code" do
+      dispatch_to(TestController, :success_action).status.should be_successful
+    end
+  end
+  
+  describe "#be_missing" do
+    it "should work with the result of a dispatch_to helper call" do
+      dispatch_to(TestController, :missing_action).should be_missing
+    end
+    
+    it "should work with the result of a get helper call" do
+      get("/missing").should be_client_error
+    end
+    
+    it "should work with a redirection code" do
+      dispatch_to(TestController, :missing_action).status.should be_missing
+    end
+  end
+end
+
+module Merb::Test::Rspec
+  module ControllerMatchers
+    class RedirectableTarget
+      attr_accessor :status, :headers
+      def initialize; @headers = {}; end
+    end
+    
+    describe BeRedirect do
+      before(:each) do
+        @target = RedirectableTarget.new
+      end
+      
+      it "should match a 301 'Moved Permanently' redirect code" do
+        BeRedirect.new.matches?(301).should be_true
+      end
+      
+      it "should match a 302 'Found' redirect code" do
+        BeRedirect.new.matches?(302).should be_true
+      end
+      
+      it "should match a 303 'See Other' redirect code" do
+        BeRedirect.new.matches?(303).should be_true
+      end
+      
+      it "should match a 304 'Not Modified' redirect code" do
+        BeRedirect.new.matches?(304).should be_true
+      end
+      
+      it "should match a 307 'Temporary Redirect' redirect code" do
+        BeRedirect.new.matches?(307).should be_true
+      end
+      
+      it "should match a target with a valid redirect code" do
+        @target.status = 301
+        
+        BeRedirect.new.matches?(@target).should be_true
+      end
+      
+      it "should not match a target with an unused redirect code" do
+        @target.status = 399
+        
+        BeRedirect.new.matches?(@target).should_not be_true
+      end
+      
+      it "should not match a target with a non redirect code" do
+        @target.status = 200
+        
+        BeRedirect.new.matches?(@target).should_not be_true
+      end
+      
+      describe "#failure_message" do
+        it "should be 'expected to redirect' when the target is a status code" do
+          matcher = BeRedirect.new
+          matcher.matches?(200)
+          matcher.failure_message.should == "expected to redirect"
+        end
+        
+        it "should be 'expected Foo#bar to redirect' when the target's controller is Foo and action is bar" do
+          matcher = BeRedirect.new
+          @target.stub!(:controller_name).and_return :Foo
+          @target.stub!(:action_name).and_return :bar
+          matcher.matches?(@target)
+          matcher.failure_message.should == "expected Foo#bar to redirect"
+        end
+      end
+      
+      describe "#negative_failure_message" do
+        it "should be 'expected not to redirect' when the target is a status code" do
+          matcher = BeRedirect.new
+          matcher.matches?(200)
+          matcher.negative_failure_message.should == "expected not to redirect"
+        end
+        
+        it "should be 'expected Foo#bar to redirect' when the target's controller is Foo and action is bar" do
+          matcher = BeRedirect.new
+          @target.stub!(:controller_name).and_return :Foo
+          @target.stub!(:action_name).and_return :bar
+          matcher.matches?(@target)
+          matcher.negative_failure_message.should == "expected Foo#bar not to redirect"
+        end
+      end
+    end
+    
+    describe RedirectTo do
+      before(:each) do
+        @target = RedirectableTarget.new
+      end
+      
+      it "should match a target if the status code is 300 level and the locations match" do
+        @target.status = 301
+        @target.headers['Location'] = "http://example.com/"
+        
+        RedirectTo.new("http://example.com/").matches?(@target).should be_true
+      end
+      
+      it "should not match a target if the status code is not 300 level but the locations match" do
+        @target.status = 404
+        @target.headers['Location'] = "http://example.com/"
+        
+        RedirectTo.new("http://example.com/").matches?(@target).should_not be_true
+      end
+      
+      it "should not match a target if the status code is 300 level but the locations do not match" do
+        @target.status = 301
+        @target.headers['Location'] = "http://merbivore.com/"
+        
+        RedirectTo.new("http://example.com/").matches?(@target).should_not be_true
+      end
+      
+      describe "#failure_message" do
+        it "should be 'expected Foo#bar to redirect to <http://expected.com/>, but was <http://target.com/>' when the expected url is http://expected.com/ and the target url is http://target.com/" do
+          @target.stub!(:controller_name).and_return :Foo
+          @target.stub!(:action_name).and_return :bar
+          @target.status = 301
+          @target.headers['Location'] = "http://target.com/"
+          matcher = RedirectTo.new("http://expected.com/")
+          matcher.matches?(@target)
+          matcher.failure_message.should == "expected Foo#bar to redirect to <http://expected.com/>, but was <http://target.com/>"
+        end
+        
+        it "should be 'expected Foo#bar to redirect, but there was no redirection' when the target is not redirected" do
+          @target.stub!(:controller_name).and_return :Foo
+          @target.stub!(:action_name).and_return :bar
+          @target.status = 200
+          @target.headers['Location'] = "http://target.com/"
+          matcher = RedirectTo.new("http://expected.com/")
+          matcher.matches?(@target)
+          matcher.failure_message.should == "expected Foo#bar to redirect to <http://expected.com/>, but there was no redirection"
+        end
+      end
+      
+      describe "#negative_failure_message" do
+        it "should be 'expected Foo#bar not to redirect to <http://expected.com/>, but it did anyways" do
+          @target.stub!(:controller_name).and_return :Foo
+          @target.stub!(:action_name).and_return :bar
+          @target.status = 200
+          @target.headers['Location'] = "http://target.com/"
+          matcher = RedirectTo.new("http://expected.com/")
+          matcher.matches?(@target)
+          matcher.negative_failure_message.should == "expected Foo#bar not to redirect to <http://expected.com/>, but did anyway"
+        end
+      end
+    end
+    
+    describe BeSuccess do
+      before(:each) do
+        @target = RedirectableTarget.new
+      end
+      
+      it "should match a target with a 200 'OK' status code" do
+        BeSuccess.new.matches?(200).should be_true
+      end
+      
+      it "should match a target with a 201 'Created' status code" do
+        BeSuccess.new.matches?(201).should be_true
+      end
+      
+      it "should match a target with a 202 'Accepted' status code" do
+        BeSuccess.new.matches?(202).should be_true
+      end
+      
+      it "should match a target with a 203 'Non-Authoritative Information' status code" do
+        BeSuccess.new.matches?(203).should be_true
+      end
+      
+      it "should match a target with a 204 'No Content' status code" do
+        BeSuccess.new.matches?(204).should be_true
+      end
+      
+      it "should match a target with a 205 'Reset Content' status code" do
+        BeSuccess.new.matches?(205).should be_true
+      end
+      
+      it "should match a target with a 206 'Partial Content' status code" do
+        BeSuccess.new.matches?(206).should be_true
+      end
+      
+      it "should match a target with a 207 'Multi-Status' status code" do
+        BeSuccess.new.matches?(207).should be_true
+      end
+      
+      it "should not match a target with an unused 200 level status code" do
+        BeSuccess.new.matches?(299).should_not be_true
+      end
+      
+      it "should not match a target with a non 200 level status code" do
+        BeSuccess.new.matches?(301).should_not be_true
+      end
+      
+      describe "#failure_message" do
+        it "should be 'expected to be successful but was 300' when the target is status code 300" do
+          matcher = BeSuccess.new
+          matcher.matches?(300)
+          matcher.failure_message.should == "expected to be successful but was 300"
+        end
+        
+        it "should be 'expected Foo#bar to be successful but was 404' when the target is controller-ish" do
+          @target.stub!(:controller_name).and_return :Foo
+          @target.stub!(:action_name).and_return :bar
+          @target.status = 404
+          matcher = BeSuccess.new
+          matcher.matches?(@target)
+          matcher.failure_message.should == "expected Foo#bar to be successful but was 404"
+        end
+      end
+      
+      describe "#negative_failure_message" do
+        it "should be 'expected not to be successful but it was' when the target is a 200 status code" do
+          matcher = BeSuccess.new
+          matcher.matches?(200)
+          matcher.negative_failure_message.should == "expected not to be successful but it was 200"
+        end
+        
+        it "should be 'expected Foo#bar not to be successful but it was 200' when the target is controller-ish" do
+          @target.stub!(:controller_name).and_return :Foo
+          @target.stub!(:action_name).and_return :bar
+          @target.status = 200
+          matcher = BeSuccess.new
+          matcher.matches?(@target)
+          matcher.negative_failure_message.should == "expected Foo#bar not to be successful but it was 200"
+        end
+      end
+    end
+    
+    describe BeMissing do
+      before(:each) do
+        @target = RedirectableTarget.new
+      end
+      
+      it "should match a 400 'Bad Request'" do
+        BeMissing.new.matches?(400).should be_true
+      end
+      
+      it "should match a 401 'Unauthorized'" do
+        BeMissing.new.matches?(401).should be_true
+      end
+      
+      it "should match a 403 'Forbidden'" do
+        BeMissing.new.matches?(403).should be_true
+      end
+      
+      it "should match a 404 'Not Found'" do
+        BeMissing.new.matches?(404).should be_true
+      end
+      
+      it "should match a 409 'Conflict'" do
+        BeMissing.new.matches?(409).should be_true
+      end
+      
+      it "should match a target with a valid client side error code" do
+        @target.status = 404
+        
+        BeMissing.new.matches?(@target).should be_true
+      end
+      
+      it "should not match a target with an unused client side error code" do
+        @target.status = 499
+        
+        BeMissing.new.matches?(@target).should_not be_true
+      end
+      
+      it "should not match a target with a non client side error code" do
+        @target.status = 200
+        
+        BeMissing.new.matches?(@target).should_not be_true
+      end
+      
+      describe "#failure_message" do
+        it "should be 'expected to be missing but was 300' when the target is status code 300" do
+          matcher = BeMissing.new
+          matcher.matches?(300)
+          matcher.failure_message.should == "expected to be missing but was 300"
+        end
+        
+        it "should be 'expected Foo#bar to be successful but was 301' when the target is controller-ish" do
+          @target.stub!(:controller_name).and_return :Foo
+          @target.stub!(:action_name).and_return :bar
+          @target.status = 301
+          matcher = BeMissing.new
+          matcher.matches?(@target)
+          matcher.failure_message.should == "expected Foo#bar to be missing but was 301"
+        end
+      end
+      
+      describe "#negative_failure_message" do
+        it "should be 'expected not to be successful but it was' when the target is a 400 status code" do
+          matcher = BeMissing.new
+          matcher.matches?(400)
+          matcher.negative_failure_message.should == "expected not to be missing but it was 400"
+        end
+        
+        it "should be 'expected Foo#bar not to be missing but it was 404' when the target is controller-ish" do
+          @target.stub!(:controller_name).and_return :Foo
+          @target.stub!(:action_name).and_return :bar
+          @target.status = 404
+          matcher = BeMissing.new
+          matcher.matches?(@target)
+          matcher.negative_failure_message.should == "expected Foo#bar not to be missing but it was 404"
+        end
+      end
+    end
+
+    describe Provide do
+      class TestController < Merb::Controller
+        provides :xml
+      end
+
+      it 'should match for formats a controller class provides' do
+        Provide.new( :xml ).matches?( TestController ).should be_true
+      end
+
+      it 'should match for formats a controller instance provides' do
+        t = TestController.new( fake_request )
+        Provide.new( :xml ).matches?( t ).should be_true
+      end
+
+      it 'should not match for formats a controller class does not provide' do
+        Provide.new( :yaml ).matches?( TestController ).should be_false
+      end
+
+      it 'should not match for formats a controller instance does not provide' do
+        t = TestController.new( fake_request )
+        Provide.new( :yaml ).matches?( t ).should be_false
+      end
+    end
+  end
+end