hassox-pancake 0.1.6

data/spec/pancake/stack/stack_configuration_spec.rb

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "pancake stack configuration" do
+
+  before(:each) do
+    Pancake.configuration.stacks.clear
+    Pancake.configuration.configs.clear
+    class ::FooStack < Pancake::Stack
+    end
+    FooStack.roots << Pancake.get_root(__FILE__)
+  end
+
+  after(:each) do
+    clear_constants(:FooStack)
+  end
+
+  it "should provide access to the stack configuration" do
+    FooStack.configuration.class.should inherit_from(Pancake::Configuration::Base)
+  end
+
+  it "should allow me to set defaults on a stack" do
+    FooStack.configuration do
+      default :foo, :bar
+      default :bar, "Foo Bar Man"
+    end
+    FooStack.configuration.foo.should == :bar
+    FooStack.configuration.bar.should == "Foo Bar Man"
+  end
+
+  it "should allow me to extend the configuration" do
+    class Pancake::Stack::Configuration
+      default :foo, :bar, "I am a foo default"
+      default :bar do
+        foobar
+      end
+
+      def foobar
+        :foobar
+      end
+    end
+    class FooBarStack < Pancake::Stack; end
+
+    FooBarStack.configuration.foo.should == :bar
+    FooBarStack.configuration.bar.should == :foobar
+  end
+
+  describe "configurations" do
+
+    it "should provide a configuration object for the stack" do
+      app = FooStack.stackup
+      app.configuration.should be_an_instance_of(FooStack::Configuration)
+    end
+
+    it "should put a copy of the application at the stack identified by the class" do
+      router = FooStack.stackup
+      Pancake.configuration.stacks[FooStack].should be_an_instance_of(FooStack)
+    end
+
+    it "should allow me to set a configuration object manually" do
+      config = FooStack::Configuration.new
+      app = FooStack.stackup(:config => config)
+      app.configuration.should equal(config)
+    end
+
+    it "should allow me to have access to the configuration object when creating the stack through a block" do
+      app = FooStack.stackup do |config|
+        config.foo = :foo
+        config.bar = :bar
+      end
+      app.configuration.foo.should == :foo
+      app.configuration.bar.should == :bar
+    end
+
+    it "should setup access to the configuration object through Pancakes configuration" do
+      router = FooStack.stackup
+      Pancake.configuration.stacks(FooStack).should be_an_instance_of(FooStack)
+      Pancake.configuration.configs(FooStack).should equal router.configuration
+    end
+
+    it "should allow me to create a configuration with a label" do
+      FooStack.configuration(:my_config).should be_an_instance_of(FooStack::Configuration)
+      FooStack.configuration(:my_config).should_not equal(FooStack.configuration)
+    end
+
+    it "should create a stack with an app_name" do
+      FooStack.stackup(:app_name => "my.app.name")
+      Pancake.configuration.stacks(FooStack).should be_nil
+      Pancake.configuration.stacks("my.app.name").should be_an_instance_of(FooStack)
+      Pancake.configuration.configs("my.app.name").should be_an_instance_of(FooStack::Configuration)
+    end
+
+    it "should provide access to the configuration in a block" do
+      Pancake.configuration.configs(FooStack) do |config|
+        config.foo = :foo
+      end
+      @app = FooStack.stackup
+      @app.configuration.foo.should == :foo
+    end
+  end
+
+end

data/spec/pancake/stack/stack_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "Pancake::Stack" do
+  before(:each) do
+    class ::StackSpecStack < Pancake::Stack
+    end
+  end
+  
+  after(:each) do
+    clear_constants(:StackSpecStack)
+  end
+  
+  describe "roots" do
+  
+    it "should provide access to setting the roots" do
+      StackSpecStack.roots.should be_empty
+      StackSpecStack.roots << File.expand_path(File.dirname(__FILE__))
+      StackSpecStack.roots.should include(File.expand_path(File.dirname(__FILE__)))
+    end
+  
+    it "should provide access to adding a root" do
+      StackSpecStack.roots.should be_empty
+      StackSpecStack.roots << Pancake.get_root(__FILE__)
+      StackSpecStack.roots.should include(File.expand_path(File.dirname(__FILE__)))
+    end
+  
+    it "should allow me to get multiple roots in the order they're added" do
+      StackSpecStack.roots.should be_empty
+      StackSpecStack.roots << Pancake.get_root(__FILE__)
+      StackSpecStack.roots << "/tmp"
+      StackSpecStack.roots.should == [Pancake.get_root(__FILE__), "/tmp"]
+    end
+  
+    it "should iterate over the roots in the direction they're added" do
+      StackSpecStack.roots.should be_empty
+      StackSpecStack.roots << Pancake.get_root(__FILE__)
+      StackSpecStack.roots << "/foo"
+      StackSpecStack.roots.map{|f| f}.should == [Pancake.get_root(__FILE__), "/foo"]
+    end
+  end # roots
+  
+  # describe "initialize stack" do
+
+    it "should mark a stack as initialized once it has called the initialize_stack method" do
+      StackSpecStack::BootLoader
+      StackSpecStack.roots << ::Pancake.get_root(__FILE__)
+      StackSpecStack.initialize_stack
+      StackSpecStack.should be_initialized
+    end
+    
+    it "should not be initialized when it has not called initialize_stack" do
+      StackSpecStack.should_not be_initialized
+    end    
+  # end
+end

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

@@ -0,0 +1,287 @@
+require File.join(File.expand_path(File.dirname(__FILE__)),'..', '..', '..', 'spec_helper')
+
+describe Pancake::Stacks::Short::Controller do
+  
+  before do
+    class ::ShortFoo < Pancake::Stacks::Short
+      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
+    ShortFoo.roots << Pancake.get_root(__FILE__)
+  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
+    
+    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
+        
+      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
+  end
+end

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

@@ -0,0 +1,132 @@
+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 "/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