pancake 0.1.8

data/spec/pancake/stacks/short/controller_spec.rb

@@ -0,0 +1,322 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),'..', '..', '..', 'spec_helper')
+
+describe Pancake::Stacks::Short::Controller do
+
+  before do
+    class ::ShortFoo < Pancake::Stacks::Short
+      add_root(__FILE__)
+      add_root(File.expand_path(File.dirname(__FILE__)), "..", "fixtures", "stacks", "short", "foobar")
+      class Controller
+        def do_dispatch!
+          dispatch!
+        end
+
+        publish
+        def show;   "show";    end
+
+        publish
+        def index;  "index";   end
+
+        protected
+        def a_protected_method; "protected"; end
+
+        private
+        def a_private_method; "private"; end
+      end
+    end
+  end
+
+  after do
+    clear_constants "ShortFoo", :ShortBar
+  end
+
+  def app
+    ShortFoo.stackup
+  end
+
+  it "should have a Controller" do
+    Pancake::Stacks::Short.constants.map(&:to_s).should include("Controller")
+  end
+
+  it "should inherit the subclass controller from the parent controller" do
+    ShortFoo::Controller.should inherit_from(Pancake::Stacks::Short::Controller)
+  end
+
+  describe "dispatching an action" do
+    before do
+      @controller = ShortFoo::Controller.new(env_for)
+    end
+
+    it "should call the 'show' action" do
+      @controller.params["action"] = "show"
+      result = @controller.do_dispatch!
+      result[0].should == 200
+      result[2].body.join.should  == "show"
+    end
+
+    it "should raise a Pancake::Response::NotFound exception when an action is now found" do
+      @controller.params["action"] = :does_not_exist
+      result = @controller.do_dispatch!
+      result[0].should == 404
+    end
+
+    it "should not dispatch to a protected method" do
+      @controller.params["action"] = "a_protected_method"
+      result = @controller.do_dispatch!
+      result[0].should == 404
+    end
+
+    it "should not dispatch to a private method" do
+      @controller.params["action"] = "a_private_method"
+      result = @controller.do_dispatch!
+      result[0].should == 404
+    end
+
+    it "should raise an exception if pancake has told it not to handle errors" do
+      Pancake.should_receive(:handle_errors?).and_return(false)
+      @controller.params["action"] = "a_private_method"
+      lambda do
+        @controller.do_dispatch!
+      end.should raise_error
+    end
+
+    describe "helper in methods" do
+      before do
+        module PancakeTestHelper
+          def some_helper_method
+            "foo"
+          end
+        end
+
+        class ShortFoo
+          class Controller
+            include PancakeTestHelper
+          end
+        end
+      end
+      after do
+        clear_constants "PancakeTestHelper"
+      end
+
+      it "should not call a helper method" do
+        @controller.params["action"] = "some_helper_method"
+        result = @controller.do_dispatch!
+        result[0].should == 404
+      end
+
+    end
+  end
+
+  describe "accept type negotiations" do
+    before do
+      class ::ShortBar < Pancake::Stacks::Short
+        roots << Pancake.get_root(__FILE__)
+        # makes the dispatch method public
+        def do_dispatch!
+          dispatch!
+        end
+
+        provides :json, :xml, :text
+
+        get "/foo/bar(.:format)" do
+          "format #{content_type.inspect}"
+        end
+      end # ShortBar
+    end # before
+
+    def app
+      ShortBar.stackup
+    end
+
+    it "should get json by default" do
+      result = get "/foo/bar", {}, "HTTP_ACCEPT" => "application/json"
+      result.status.should == 200
+      result.headers["Content-Type"].should == "application/json"
+      result.body.to_s.should == "format :json"
+    end
+
+    it "should get xml when specified" do
+      result = get "/foo/bar.xml"
+      result.status.should == 200
+      result.headers["Content-Type"].should == "application/xml"
+      result.body.to_s.should == "format :xml"
+    end
+
+    it "should get json when specified with */*" do
+      result = get "/foo/bar", {}, "HTTP_ACCEPT" => "*/*"
+      result.status.should == 200
+      result.body.to_s.should == "format :json"
+      result.headers["Content-Type"].should == "application/json"
+    end
+
+    it "should get the default when specified with */*" do
+      result = get "/foo/bar", {}, "HTTP_ACCEPT" => "application/xml,*/*"
+      result.status.should == 200
+      result.body.to_s.should == "format :json"
+      result.headers["Content-Type"].should == "application/json"
+    end
+
+    it "should use the format in preference to the content type" do
+      result = get "/foo/bar.xml", {}, "HTTP_ACCEPT" => "*/*"
+      result.status.should == 200
+      result.body.to_s.should == "format :xml"
+      result.headers["Content-Type"].should == "application/xml"
+    end
+
+    it "should get json by default" do
+      result = get "/foo/bar"
+      result.status.should == 200
+      result.body.to_s.should == "format :json"
+      result.headers["Content-Type"].should == "application/json"
+    end
+
+    it "should correctly negotiate different scenarios" do
+      r = get "/foo/bar", {}, {}
+      r.body.should == "format :json"
+      r = get "/foo/bar.xml", {}, {}
+      r.body.should == "format :xml"
+      r = get "/foo/bar", {}, {}
+      r.body.should == "format :json"
+      r = get "/foo/bar", {}, "HTTP_ACCEPT" => "application/xml"
+      r.body.should == "format :xml"
+      r = get "/foo/bar.json"
+      r.body.should == "format :json"
+    end
+
+    it "should negotiate based on extension" do
+      r = get "/foo/bar"
+      r.body.should == "format :json"
+      r = get "/foo/bar.text"
+      r.body.should == "format :text"
+      r = get "/foo/bar.xml"
+      r.body.should == "format :xml"
+      r = get "/foo/bar.txt"
+      r.body.should == "format :text"
+    end
+
+    it "should not provide a response to a format that is not provided" do
+      r = get "/foo/bar.svg"
+      r.status.should == 406
+    end
+  end # Accept type negotiations
+
+  describe "error handling" do
+    before do
+      class ::ShortFoo
+        provides :html, :xml
+
+        get "/foo(.:format)" do
+          "HERE"
+        end
+
+        get "/bad" do
+          raise "This is bad"
+        end
+
+        get "/template/:name" do
+          render params[:name]
+        end
+
+      end
+    end
+
+    describe "default error handling" do
+      def app
+        ShortFoo.stackup
+      end
+
+      it "should handle a NotFound  by default" do
+        result = get "/does_not_exist"
+        result.status.should == 404
+        result.body.should include(Pancake::Errors::NotFound.description)
+      end
+
+      it "should return a 500 status for a Random Error by wrapping it in a Pancake::Errors::Server" do
+        result = get "/bad"
+        result.status.should == 500
+        result.body.should include(Pancake::Errors::Server.description)
+      end
+
+      it "should handle a NotAcceptable error" do
+        result = get "/foo.no_format_i_know_of"
+        result.status.should == 406
+        result.body.should include(Pancake::Errors::NotAcceptable.description)
+      end
+
+      it "should return 406 for a format that is in pancake but not in the group" do
+        r = get "/foo.svg"
+        r.status.should == 406
+      end
+
+
+    end
+
+    describe "custom error handling" do
+      before do
+        ShortFoo.handle_exception do |error|
+          out = ""
+          out << "CUSTOM "
+          out << error.name
+          out << ": "
+          out << error.description
+        end
+
+        ShortFoo.get "/bad" do
+          raise "Really Bad"
+        end
+      end
+
+      after do
+        ShortFoo.handle_exception(&Pancake::Stacks::Short::Controller::DEFAULT_EXCEPTION_HANDLER)
+      end
+
+      it "should handle Pancake::Errors::NotFound errors" do
+        r = get "/not_a_thing"
+        r.status.should == 404
+        r.body.should include("CUSTOM")
+        r.body.should include(Pancake::Errors::NotFound.description)
+      end
+
+      it "should handle an unknown server error" do
+        r = get "/bad"
+        r.status.should == 500
+        r.body.should include("CUSTOM")
+        r.body.should include(Pancake::Errors::Server.description)
+      end
+
+      it "should let me do stuff on an instance level inside the handle exception" do
+        ShortFoo.handle_exception do |error|
+          self.status = 123
+          "BOOO!"
+        end
+
+        r = get "/bad"
+        r.status.should == 123
+        r.body.should == "BOOO!"
+      end
+
+    end
+
+    describe "rendering" do
+
+      it "should render a template" do
+        result = get "/template/basic"
+        result.body.should include("basic template")
+      end
+
+      it "should inherit from a base view provided by short stacks" do
+        File.file?(File.join(File.expand_path(File.dirname(__FILE__)), "..", "fixtures", "stacks", "short", "foobar", "views", "base.html.haml")).should be_false
+        result = get "/template/inherited_from_base"
+        result.body.should include("inherited from base")
+        result.body.should include("Pancake")
+      end
+
+      it "should allow me to overwrite the base tempalte in later roots" do
+        ShortFoo.add_root(File.expand_path(File.dirname(__FILE__)), "..", "fixtures", "stacks", "short", "foobar", "other_root")
+        result = get "/template/inherited_from_base"
+        result.body.should include("inherited from base")
+        result.body.should include("Not the default pancake")
+      end
+    end
+  end
+end

data/spec/pancake/stacks/short/middlewares_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "short stack middleware" do
+  before do
+    class ::FooBar < Pancake::Stacks::Short
+      add_root(__FILE__)
+    end
+  end
+
+  after do
+    clear_constants :FooBar
+  end
+
+  it "should include the Pancake::Middlewares::Static middleware" do
+    FooBar.stackup
+    middleware = FooBar.middlewares.detect do |m|
+      m.middleware == Pancake::Middlewares::Static
+    end
+    middleware.should_not be_nil
+    middleware.args.should == [FooBar]
+  end
+end

data/spec/pancake/stacks/short/router_spec.rb

@@ -0,0 +1,136 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),'..', '..', '..', 'spec_helper')
+
+describe Pancake::Stacks::Short, "routes" do
+  before do
+    class ::RoutedShortStack < Pancake::Stacks::Short
+      roots << Pancake.get_root(__FILE__)
+
+      get "/", :_name => :root do
+        "get - /"
+      end
+
+      get "/foo", :_name => :foo do
+        "get - foo"
+      end
+
+      get "/bar", :_name => :bar do
+        "get - bar"
+      end
+
+      post "/foo" do
+        "post - foo"
+      end
+
+      post "/bar" do
+        "post - bar"
+      end
+
+      put "/foo" do
+        "put - foo"
+      end
+
+      put "/bar" do
+        "put - bar"
+      end
+
+      delete "/foo" do
+        "delete - foo"
+      end
+
+      delete "/bar" do
+        "delete - bar"
+      end
+
+      get "/baz/:var(/:date)" do
+        "done: var == #{params[:var]} : date == #{params[:date]}"
+      end.name(:baz)
+    end
+    @app = RoutedShortStack.stackup
+  end
+  after do
+    clear_constants "RoutedShortStack", "FooApp", "BarApp"
+  end
+
+  def app
+    @app
+  end
+
+  %w(foo bar).each do |item|
+    %w(get post put delete).each do |method|
+      it "should #{method} /#{item}" do
+        result = self.send(method, "/#{item}")
+        result.status.should == 200
+        result.body.should == "#{method} - #{item}"
+      end
+    end # get post put delete
+  end # foo bar
+
+  it "should return a not found if we try to get an action that has not been defined" do
+    result = get "/blah"
+    result.status.should == 404
+  end
+
+
+  it "should handle tricky routes" do
+    result = get "/baz/hassox"
+    result.status.should == 200
+    result.body.should == "done: var == hassox : date == "
+  end
+
+  it "should handle tricky routes with optional parameters" do
+    result = get "/baz/hassox/2009-08-21"
+    result.status.should == 200
+    result.body.should == "done: var == hassox : date == 2009-08-21"
+  end
+
+  describe "url generation" do
+    it "should generate a simple named  url" do
+      Pancake.url(RoutedShortStack, :foo).should == "/foo"
+    end
+
+    it "should generate a complex named  url" do
+      Pancake.url(RoutedShortStack, :baz, :var => "bar").should == "/baz/bar"
+      Pancake.url(RoutedShortStack, :baz, :var => "bar", :date => "today").should == "/baz/bar/today"
+    end
+
+    it "should generate it's url when it's nested" do
+      class ::FooApp < Pancake::Stack; end
+      FooApp.router.mount(RoutedShortStack.stackup, "/short/stack")
+      Pancake.url(RoutedShortStack, :foo).should == "/short/stack/foo"
+      Pancake.url(RoutedShortStack, :baz, :var => "var", :date => "today").should == "/short/stack/baz/var/today"
+    end
+  end
+
+  describe "inherited route generation" do
+    before do
+      class ::FooApp < RoutedShortStack; end
+      @app = FooApp.stackup
+    end
+
+    it "should generate an inherited simple url" do
+      Pancake.url(FooApp, :foo).should == "/foo"
+    end
+
+    it "should generate a complex url" do
+      Pancake.url(FooApp, :baz, :var => "the_var", :date => "today").should == "/baz/the_var/today"
+    end
+
+    %w(foo bar).each do |item|
+      %w(get post put delete).each do |method|
+        it "should #{method} /#{item}" do
+          result = self.send(method, "/#{item}")
+          result.status.should == 200
+          result.body.should == "#{method} - #{item}"
+        end
+      end # get post put delete
+    end # foo bar
+
+    it "should match the nested route without affecting the parent" do
+      class ::BarApp < Pancake::Stack; end
+      BarApp.router.mount(FooApp.stackup, "/mount/point")
+
+      Pancake.url(FooApp, :foo).should == "/mount/point/foo"
+      Pancake.url(RoutedShortStack, :foo).should == "/foo"
+    end
+  end
+end

data/spec/pancake/stacks/short/stack_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Pancake::Stacks::Short do
+
+  before do
+    $captures = []
+    class ::ShortMiddle
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        $captures << ShortMiddle
+        @app.call(env)
+      end
+    end
+
+    class ::ShortFoo < Pancake::Stacks::Short
+      roots << Pancake.get_root(__FILE__)
+      add_root(__FILE__, "..", "..", "fixtures", "stacks", "short", "foobar")
+      add_root(__FILE__, "..", "..", "fixtures", "stacks", "short", "foobar", "other_root")
+      use ShortMiddle
+
+
+      get "/foo" do
+        "HERE"
+      end
+
+      get "/" do
+        $captures << self.class
+        render :inherited_from_base
+      end
+    end
+  end
+
+  after do
+    clear_constants :ShortFoo, :ShortMiddle, :OtherFoo
+  end
+
+  def app
+    ShortFoo.stackup
+  end
+
+  it "should go through the middleware to get to the actions" do
+    get "/foo"
+    $captures.should == [ShortMiddle]
+  end
+
+  describe "inheritance" do
+    before do
+      class ::OtherFoo < ShortFoo; end
+      ShortFoo.router.mount(OtherFoo.stackup, "/other")
+    end
+
+    it "should render the same template in the child as it does in the parent" do
+      get "/"
+      $captures.pop.should == ShortFoo::Controller
+      last_response.should match(/inherited from base/)
+      get "/other/"
+      $captures.pop.should == OtherFoo::Controller
+      last_response.should match(/inherited from base/)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+$TESTING=true
+require 'rubygems'
+require 'date'
+require 'rack'
+require 'rack/test'
+require 'spec/rake/spectask'
+require 'spec'
+require 'haml'
+require 'json'
+
+ENV['RACK_ENV'] = "test"
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'pancake'
+
+Dir[File.join(File.dirname(__FILE__), "helpers", "**/*.rb")].each{|f| require f}
+
+
+Spec::Runner.configure do |config|
+  config.include(Pancake::Matchers)
+  config.include(Pancake::Spec::Helpers)
+  config.include(Rack::Test::Methods)
+end