hassox-pancake 0.1.6

data/spec/pancake/configuration_spec.rb

@@ -0,0 +1,177 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Pancake::Configuration" do
+
+  it "should let me make a new configuration" do
+    conf_klass = Pancake::Configuration.make
+    conf_klass.should inherit_from(Pancake::Configuration::Base)
+  end
+
+  describe "usage" do
+    before(:each) do
+      @Conf = Pancake::Configuration.make
+    end
+
+    it "should let me set defaults" do
+      @Conf.default :foo, :bar
+      c = @Conf.new
+      c.foo.should == :bar
+      @Conf.new.foo.should == :bar
+    end
+
+    it "should let me set a description on the default" do
+      @Conf.default :foo, :bar
+      @Conf.default :bar, :baz, "A description of bar"
+      c = @Conf.new
+      c.foo.should == :bar
+      c.bar.should == :baz
+      c.defaults[:foo][:description].should == ""
+      c.defaults[:bar][:description].should == "A description of bar"
+    end
+
+    it "should allow me to make multiple different configuration objects without polluting each other" do
+      c1 = Pancake::Configuration.make
+      c2 = Pancake::Configuration.make
+      c1.default :foo, :bar
+      c2.default :foo, :baz, "A description of foo"
+      c1i, c2i = c1.new, c2.new
+      c1i.foo.should == :bar
+      c1i.defaults[:foo][:value].should == :bar
+      c1i.defaults[:foo][:description].should == ""
+      c2i.foo.should == :baz
+      c2i.defaults[:foo][:value].should == :baz
+      c2i.defaults[:foo][:description].should == "A description of foo"
+    end
+
+    it "should allow me to define defaults in the make block" do
+      c1 = Pancake::Configuration.make do
+        default :foo, :bar, "Foo Desc"
+        default :baz, 42,   "The Answer"
+      end
+      c = c1.new
+      c.foo.should == :bar
+      c.baz.should == 42
+    end
+
+    it "should overwrite the default values" do
+      @Conf.default :foo, :bar
+      c = @Conf.new
+      c.foo = :baz
+      c.foo.inspect
+      c.foo.should == :baz
+      c.defaults[:foo][:value].should == :bar
+    end
+
+    it "should not add a default value for values I set blindly" do
+      c = @Conf.new
+      c.bar.should be_nil
+      c.defaults.keys.should_not include(:bar)
+    end
+
+    it "should allow me to set a value then the default and not get mixed up" do
+      c = @Conf.new
+      c.bar = :foo
+      c.defaults[:bar][:value].should == nil
+    end
+
+    it "should let me declare defaults after I've initizlied the configuartion object" do
+      c = @Conf.new
+      @Conf.default :foo, :bar
+      c.foo.should == :bar
+    end
+
+    it "should give me a list of the current defaults" do
+      @Conf.default :foo, :bar
+      @Conf.default :bar, :baz, "Some description"
+      c = @Conf.new
+      c.defaults.should == {
+        :foo => {
+          :description  => "",
+          :value        => :bar
+        },
+        :bar => {
+          :description  => "Some description",
+          :value        => :baz
+        }
+      }
+    end
+
+    it "should give me a description for a default" do
+      @Conf.default :foo, :bar, "foo description"
+      c = @Conf.new
+      c.description_for(:foo).should == "foo description"
+    end
+
+    it "should give me a list of values for the current object" do
+      @Conf.default :foo, :bar
+      c = @Conf.new
+      c.values.should == {}
+      c.foo
+      c.values.should == {:foo => :bar}
+      c.baz = :paz
+      c.values.should == {:foo => :bar, :baz => :paz}
+    end
+
+    it "should allow me to define methods in the make block" do
+      c = Pancake::Configuration.make do
+        default :foo, :bar
+
+        default :bar do
+          foobar
+        end
+
+        def foobar
+          "This is in foobar"
+        end
+      end
+
+      ci = c.new
+      ci.foo.should == :bar
+      ci.bar.should == "This is in foobar"
+    end
+
+    it "should not cache the default when it's defined in a block" do
+      c = Pancake::Configuration.make do
+        default :foo do
+          bar
+        end
+        default :bar, :bar
+      end
+      ci = c.new
+      ci.foo.should == :bar
+      ci.bar = :baz
+      ci.bar.should == :baz
+      ci.foo.should == :baz
+    end
+
+    it "should overwrite the proc when set directly" do
+      @Conf.default :foo, :foo
+      @Conf.default(:bar){ foo }
+      ci = @Conf.new
+      ci.bar.should == :foo
+      ci.foo = :baz
+      ci.bar.should == :baz
+      ci.bar = :foobar
+      ci.bar.should == :foobar
+    end
+
+    it "should not cache nil when accessing before defaults are set" do
+      c = @Conf.new
+      c.foo.should be_nil
+      @Conf.default :foo, :bar
+      c.foo.should == :bar
+      c.foo = :baz
+      c.foo.should == :baz
+    end
+
+  end
+end
+
+
+describe "pancake configuartion" do
+
+  it "should provide access to it's configuration object" do
+    Pancake.configuration.class.should inherit_from(Pancake::Configuration::Base)
+  end
+
+end

data/spec/pancake/fixtures/render_templates/context_template.html.erb

@@ -0,0 +1 @@
+<%= the_current_context %>

data/spec/pancake/fixtures/render_templates/erb_template.html.erb

@@ -0,0 +1 @@
+IN ERB

data/spec/pancake/fixtures/render_templates/erb_template.json.erb

@@ -0,0 +1 @@
+IN ERB JSON

data/spec/pancake/fixtures/render_templates/haml_template.html.haml

@@ -0,0 +1 @@
+IN HAML

data/spec/pancake/fixtures/render_templates/haml_template.xml.haml

@@ -0,0 +1 @@
+IN HAML XML

data/spec/pancake/hooks/on_inherit_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "Pancake::Stack inheritance" do
+  describe "inheritance hooks" do
+    before(:all) do
+      $on_inherit_blocks = Pancake::Stack.on_inherit.dup
+    end
+    after(:all) do
+      Pancake::Stack.on_inherit.clear
+      $on_inherit_blocks.each do |blk|
+        Pancake::Stack.on_inherit(&blk)
+      end
+    end
+  
+    before(:each) do
+      $collector = []
+      clear_constants(:FooStack)
+      Pancake::Stack.on_inherit.clear
+    end
+  
+    after(:each) do
+      clear_constants(:FooStack)
+    end
+  
+    it "should be able to add inheritance hooks" do
+      Pancake::Stack.on_inherit do |base, parent|
+        $collector << base
+      end
+      class ::FooStack < Pancake::Stack; end
+      $collector.should == [FooStack]
+    end
+  
+    it "should be able to add multiple inheritance hooks" do
+      Pancake::Stack.on_inherit{|b,p| $collector << b}
+      Pancake::Stack.on_inherit{|b,p| $collector << :foo}
+    
+      class ::FooStack < Pancake::Stack
+      end
+    
+      $collector.should == [FooStack, :foo]
+    end
+    
+  end
+  
+  describe "Inheriting Stacks" do
+    before(:all) do 
+      clear_constants(:FooStack, :BarStack)
+    end
+    
+    before(:each) do
+      class ::FooStack < Pancake::Stack; end
+    end
+    
+    after(:each) do
+      clear_constants(:FooStack, :BarStack)
+    end
+    
+    describe "configuration" do
+      it "should inherit the configuration with a stack" do
+        class ::BarStack < ::FooStack; end
+        BarStack::Configuration.should inherit_from(FooStack::Configuration)
+      end
+    end
+  end
+end

data/spec/pancake/inheritance_spec.rb

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Pancake Inheritance" do
+  describe "on inherit hook" do
+  
+    before(:each) do
+      clear_constants(:MyFoo, :OtherFoo, :FutherFoo, :SomeFoo, :DeeperFoo)
+      class ::MyFoo 
+        extend Pancake::Hooks::OnInherit
+      end
+    
+      ::MyFoo.on_inherit do |base, parent|
+        $inherited_capture << {:base => base, :parent => parent}
+      end
+      
+      $inherited_capture = []
+    end
+  
+    it "should provide on_inherit callbacks" do
+      class ::OtherFoo < MyFoo; end
+      $inherited_capture.should  == [{:base => OtherFoo, :parent => MyFoo}]
+    end
+    
+    it "should inherit multiple times" do
+      class ::OtherFoo < MyFoo; end
+      class ::FurtherFoo < OtherFoo; end
+      $inherited_capture.should == [{:base => OtherFoo, :parent => MyFoo}, {:base => FurtherFoo, :parent => OtherFoo}]
+    end
+    
+    it "should allow for multiple callbacks" do
+      MyFoo.on_inherit{|base, parent| $inherited_capture << :second}
+      class ::OtherFoo < MyFoo; end
+      $inherited_capture.should == [{:base => OtherFoo, :parent => MyFoo}, :second]
+    end
+    
+    it "should allow for multiple callbacks that are inherited" do
+      MyFoo.on_inherit{|base, parent| $inherited_capture << :second}
+      class ::OtherFoo < MyFoo; end
+      $inherited_capture = []
+      OtherFoo.on_inherit{|base, parent| $inherited_capture << :inherited}
+      class ::SomeFoo < OtherFoo; end
+      $inherited_capture.should == [{:base => SomeFoo, :parent => OtherFoo}, :second, :inherited]      
+    end
+    
+    it "should not pollute the parent with the child inherited hooks" do
+      class ::OtherFoo < MyFoo; end
+      $inherited_capture = []
+      OtherFoo.on_inherit{|b,p| $inherited_captuer << :should_not_be_in_there}
+      class ::SomeFoo < MyFoo; end
+      $inherited_capture.should == [{:base => SomeFoo, :parent => MyFoo}]
+    end
+  end # "on inherit hook"
+  
+  describe "inheritable inner classes" do
+    
+    before(:each) do
+      clear_constants(:MyFoo, :OtherFoo, :InnerFoo, :SomeFoo, :DeeperFoo)
+      
+      class ::MyFoo
+        inheritable_inner_classes :InnerFoo
+        class InnerFoo; end
+      end
+    end
+    
+    it "should inherit the inner class along with the outer class" do
+      class ::OtherFoo < MyFoo; end
+      OtherFoo::InnerFoo.superclass.should equal(MyFoo::InnerFoo)
+      OtherFoo::InnerFoo.should_not equal(MyFoo::InnerFoo)
+    end
+    
+    it "should inherit the inner class multiple times" do
+      class ::OtherFoo < MyFoo; end
+      class ::SomeFoo < OtherFoo; end
+      class ::DeeperFoo < SomeFoo; end
+      
+      SomeFoo::InnerFoo.superclass.should equal(OtherFoo::InnerFoo)
+      SomeFoo::InnerFoo.should_not equal(OtherFoo::InnerFoo)
+      DeeperFoo::InnerFoo.superclass.should equal(SomeFoo::InnerFoo)
+      DeeperFoo::InnerFoo.should_not equal(OtherFoo::InnerFoo)
+      DeeperFoo::InnerFoo.superclass.should equal(SomeFoo::InnerFoo)
+    end
+    
+    it "should allow additional inner classes to be declared without polluting the parent" do
+      class ::OtherFoo < MyFoo
+        inheritable_inner_classes :SomeDeepFoo
+        class SomeDeepFoo; end
+      end
+      
+      class ::SomeFoo < MyFoo; end
+      class ::DeeperFoo < ::OtherFoo; end
+      
+      SomeFoo::InnerFoo.should inherit_from(MyFoo::InnerFoo)
+      SomeFoo.const_defined?(:SomeDeepFoo).should be_false
+      
+      DeeperFoo::InnerFoo.should inherit_from(OtherFoo::InnerFoo)
+      DeeperFoo::SomeDeepFoo.should inherit_from(OtherFoo::SomeDeepFoo)
+    end
+
+  end # "inheritable inner classes"
+end

data/spec/pancake/middleware_spec.rb

@@ -0,0 +1,401 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Pancake::Middleware" do
+  before(:all) do
+    $pk_mid = Pancake.middlewares.dup
+  end
+
+  after(:all) do
+    Pancake.middlewares.replace $pk_mid
+  end
+
+  before(:each) do
+    Pancake.middlewares.clear
+    def app
+      @app
+    end
+
+    def default_env
+      Rack::MockRequest.env_for
+    end
+
+    $current_env = {}
+
+    class ::GeneralMiddleware
+      attr_accessor :app
+      def initialize(app, opts={});@app = app; end
+
+      def mark_env(env)
+        env["p.s.c"] ||= []
+        env["p.s.c"] << self.class
+      end
+
+      def call(env)
+        mark_env(env)
+        @app.call(env)
+      end
+    end # GeneralMiddlware
+
+    class ::FooApp < Pancake::Stack
+      def self.new_app_instance; self end
+
+      def self.call(env)
+        $current_env = env
+        [200,{"Content-Type" => "text/plain"}, [name]]
+      end
+    end # FooApp
+    FooApp.roots << Pancake.get_root("/tmp")
+  end
+
+  after(:each) do
+    clear_constants(:FooApp, :BarApp, :BazApp, :GeneralMiddleware, :BarMiddle, :FooMiddle, :BazMiddle, :PazMiddle)
+  end
+
+  describe "pancake middlewares" do
+    before(:each) do
+      @root = File.join(Pancake.get_root(__FILE__), "fixtures", "foo_stack")
+      @the_app = Proc.new{|e| }
+      Pancake::StackMiddleware.reset!
+    end
+
+    it "should allow me to add middleware to pancake" do
+      Pancake.use GeneralMiddleware
+      @app = Pancake.start(:root => @root){ FooApp.stackup }
+      Pancake.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware]
+      get "/"
+      $current_env["p.s.c"].should include(GeneralMiddleware)
+    end
+
+    it "should allow me to add multiple middlewares to panckae" do
+      class ::FooMiddle < GeneralMiddleware; end
+      Pancake.use GeneralMiddleware
+      FooApp.use  FooMiddle
+      @app = Pancake.start(:root => @root){ FooApp.stackup }
+      get "/"
+      $current_env["p.s.c"].should == [GeneralMiddleware, FooMiddle]
+    end
+
+    it "should put the pancake middlewares out in front" do
+      class ::FooMiddle < GeneralMiddleware; end
+      class ::BarMiddle < GeneralMiddleware; end
+      class ::BarApp < FooApp; end
+      class ::BazApp < FooApp; end
+
+      BarApp.use BarMiddle
+      BazApp.use FooMiddle
+      Pancake.use GeneralMiddleware
+
+      FooApp.with_router do |r|
+        r.mount(BarApp.stackup, "/bar")
+        r.mount(BazApp.stackup, "/baz")
+      end
+
+      @app = Pancake.start(:root => @root){ FooApp.stackup }
+      get "/baz"
+      $current_env["p.s.c"].should == [GeneralMiddleware, FooMiddle]
+      get "/bar"
+      $current_env["p.s.c"].should == [GeneralMiddleware, BarMiddle]
+    end
+  end
+
+  it "should allow me to add middleware" do
+    FooApp.class_eval do
+      use GeneralMiddleware
+    end
+    @app = FooApp.stackup
+    get "/"
+    $current_env["p.s.c"].should include(GeneralMiddleware)
+  end
+
+  it "should allow me to add multiple middlewares" do
+    class ::FooMiddle < GeneralMiddleware; end
+    FooApp.class_eval do
+      use GeneralMiddleware
+      use FooMiddle
+    end
+    @app = FooApp.stackup
+    get "/"
+    [GeneralMiddleware, FooMiddle].each do |m|
+      $current_env["p.s.c"].should include(m)
+    end
+  end
+
+  it "should allow you to add middleware from outside the class" do
+    FooApp.use GeneralMiddleware
+    @app = FooApp.stackup
+    get "/"
+    $current_env["p.s.c"].should == [GeneralMiddleware]
+  end
+
+  describe "replace middleware" do
+    before(:each) do
+      FooApp.stack(:replaceable).use(GeneralMiddleware, :some => :option){ :original }
+      class FooMiddle < GeneralMiddleware; end
+    end
+
+    it "should replace the middleware with another middleware" do
+      orig = FooApp::StackMiddleware[:replaceable]
+      orig.middleware.should == GeneralMiddleware
+      orig.config.should == {:some => :option}
+
+      FooApp.stack(:replaceable).use(FooMiddle, :foo => :options)
+      replaced = FooApp.stack(:replaceable)
+      replaced.middleware.should == FooMiddle
+      replaced.config.should == {:foo => :options}
+    end
+  end
+
+  describe "deleteing middleware" do
+    before(:each) do
+      FooApp.stack(:deleteable).use(GeneralMiddleware, :some => :option){ :original }
+    end
+
+    it "should delete the middleware" do
+      orig = FooApp::StackMiddleware[:deleteable]
+      orig.should_not be_nil
+      orig.middleware.should == GeneralMiddleware
+      FooApp.stack(:deleteable).delete!
+      FooApp::StackMiddleware[:deleteable].should be_nil
+    end
+
+    it "should not include middleware that depends on being deleted" do
+      class FooMiddle < GeneralMiddleware; end
+      FooApp.stack(:foo, :after => :deleteable).use(FooMiddle)
+      FooApp.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware, FooMiddle]
+      FooApp.stack(:deleteable).delete!
+      FooApp.middlewares.map{|m| m.middleware}.should == []
+    end
+  end
+
+  describe "edit middleware" do
+    before(:each) do
+      FooApp.stack(:editable).use(GeneralMiddleware,:some => :config)
+    end
+
+    it "should allow me to update settings for middleware" do
+      FooApp.stack(:editable).config.should == {:some => :config}
+      FooApp.stack(:editable).config = {:foo => :bar}
+      FooApp.stack(:editable).config.should == {:foo => :bar}
+    end
+  end
+
+
+
+  describe "Inherited middleware" do
+    before(:each) do
+      class FooMiddle < GeneralMiddleware; end
+      class BarMiddle < GeneralMiddleware; end
+    end
+
+    it "should inherit middleware from it's parent class" do
+      FooApp.use GeneralMiddleware
+      FooApp.use FooMiddle
+      class BarApp < FooApp; end
+      BarApp.middlewares.should == FooApp.middlewares
+    end
+
+    it "should not pollute the parent when including new middlewares in the child" do
+      FooApp.use GeneralMiddleware
+      class BarApp < FooApp; end
+      BarApp.use FooMiddle
+      BarApp.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware, FooMiddle]
+      FooApp.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware]
+    end
+
+    describe "editing inherited middlware" do
+      it "should not edit the parent when editing the child" do
+        FooApp.use GeneralMiddleware, :some => :option
+        class BarApp < FooApp; end
+        BarApp.stack(GeneralMiddleware).middleware.should == GeneralMiddleware
+        BarApp.stack(GeneralMiddleware).config = {:foo => :bar}
+        BarApp.stack(GeneralMiddleware).config.should == {:foo => :bar}
+        FooApp.stack(GeneralMiddleware).config.should == {:some => :option}
+      end
+
+      it "should not update the parent when updating a childs config" do
+        FooApp.use GeneralMiddleware, :some => :option
+        class BarApp < FooApp; end
+        BarApp.stack(GeneralMiddleware).config[:another] = :option
+        FooApp.stack(GeneralMiddleware).config.should == {:some => :option}
+        BarApp.stack(GeneralMiddleware).config.should == {:some => :option, :another => :option}
+      end
+    end
+  end
+
+  describe "Stacks should inherit middleware" do
+    before(:all) do
+      $pk_middlewares = Pancake::Stack.middlewares.dup
+    end
+
+    after(:all) do
+      Pancake::Stack.middlewares.replace $pk_middlewares
+    end
+
+    before(:each) do
+      class FooMiddle < GeneralMiddleware; end
+      class BarMiddle < GeneralMiddleware; end
+    end
+
+    after(:each) do
+      Pancake::Stack::StackMiddleware.reset!
+    end
+
+    it "should clear the middlewares for the specs" do
+      Pancake::Stack.middlewares.should be_blank
+    end
+
+    it "should allow me to set middlewares on Pancake::Stack" do
+      Pancake::Stack.use GeneralMiddleware
+      Pancake::Stack.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware]
+    end
+
+    it "should carry down middlewares from the Pancake::Stack to inherited stacks" do
+      Pancake::Stack.use GeneralMiddleware
+      class FooApp < Pancake::Stack; end
+      FooApp.use FooMiddle
+      Pancake::Stack.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware]
+      FooApp.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware, FooMiddle]
+    end
+
+    it "should let me have different middlewares in different children" do
+      Pancake::Stack.use GeneralMiddleware
+      class FooApp < Pancake::Stack; end
+      FooApp.use FooMiddle
+      class BarApp < Pancake::Stack; end
+      BarApp.use BarMiddle
+      FooApp.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware, FooMiddle]
+      BarApp.middlewares.map{|m| m.middleware}.should == [GeneralMiddleware, BarMiddle]
+    end
+
+    describe "Stack Middleware Enabled Constant", :shared => true do
+
+      before(:each) do
+        raise "You must set a @konstant for the stack construction spec" unless @konstant
+        @konstant::StackMiddleware.reset!
+      end
+
+      describe "named middleware" do
+        it "should allow me to name a #{@konstant} middleware" do
+          @konstant.stack(:foo).use(GeneralMiddleware)
+          @konstant.stack[:foo].middleware.should == GeneralMiddleware
+        end
+
+        it "should implicitly name a middleware" do
+          @konstant.stack.use(GeneralMiddleware)
+          @konstant.stack[GeneralMiddleware].middleware.should == GeneralMiddleware
+        end
+      end
+
+      describe "before/after middleware" do
+        before(:each) do
+          class ::BazMiddle < GeneralMiddleware; end
+          class ::PazMiddle < GeneralMiddleware; end
+        end
+        # :FooApp, :BarApp, :BazApp, :GeneralMiddleware, :BarMiddle, :FooMiddle, :BazMiddle, :PazMiddle
+        it "should allow me to add middleware before other middleware" do
+          @konstant.use(GeneralMiddleware)
+          @konstant.stack(:bar).use(BarMiddle)
+          @konstant.stack(:foo, :before => :bar).use(FooMiddle)
+          result = @konstant.middlewares.map{|m| m.middleware}
+          result.should == [GeneralMiddleware, FooMiddle, BarMiddle]
+        end
+
+        it "should allow me to add middleware after other middleware " do
+          @konstant.use(BarMiddle)
+          @konstant.stack(:general).use(GeneralMiddleware)
+          @konstant.stack(:foo, :after => BarMiddle).use(FooMiddle)
+          result = @konstant.middlewares.map{|m| m.middleware}
+          result.should == [ BarMiddle, FooMiddle, GeneralMiddleware]
+        end
+
+        it "should allow me to add middleware arbitrarily and have it in the correct order" do
+          @konstant.use(GeneralMiddleware)
+          @konstant.stack(:bar).use(BarMiddle)
+          @konstant.stack(:foo, :before => :bar).use(FooMiddle)
+          @konstant.stack(:baz, :after  => :foo).use(BazMiddle)
+          @konstant.stack(:paz, :before => GeneralMiddleware).use(PazMiddle)
+          result = @konstant.middlewares.map{|m| m.middleware}
+          result.should == [PazMiddle, GeneralMiddleware, FooMiddle, BazMiddle, BarMiddle]
+        end
+      end
+    end
+
+    describe "Pancake Middleware Construction" do
+      before(:each) do
+        @konstant = Pancake
+      end
+
+      it_should_behave_like("Stack Middleware Enabled Constant")
+    end
+
+    describe "Pancake Stack Middleware" do
+      before(:each) do
+        @konstant = Pancake::Stack
+      end
+      it_should_behave_like("Stack Middleware Enabled Constant")
+    end
+
+    describe "An inherited panckae stack app" do
+      before(:each) do
+        class ::FooApp < Pancake::Stack; end
+        @konstant = FooApp
+      end
+      it_should_behave_like("Stack Middleware Enabled Constant")
+    end
+
+    describe "a deeply inherited stack app" do
+      before(:each) do
+        class ::FooApp < Pancake::Stack; end
+        class ::BarApp < FooApp; end
+        @konstant = BarApp
+      end
+      it_should_behave_like("Stack Middleware Enabled Constant")
+    end
+
+    it "should allow me to inherit middleware from a parent stack" do
+      class ::FooApp < Pancake::Stack; end
+      FooApp.use(GeneralMiddleware)
+      class ::BarApp < FooApp; end
+      BarApp.stack(:foo).use(FooMiddle)
+      BarApp.stack(:bar, :after => GeneralMiddleware).use(BarMiddle)
+      result = BarApp.middlewares.map{|m|m.middleware}
+      result.should == [GeneralMiddleware, BarMiddle, FooMiddle]
+    end
+
+  end # Stack Inheritance
+
+  describe "types of stacks" do
+    before(:each) do
+      class FooMiddle < GeneralMiddleware; end
+      class BarMiddle < GeneralMiddleware; end
+      class BazMiddle < GeneralMiddleware; end
+
+      FooApp.stack(:general,  :labels => [:production]        ).use(GeneralMiddleware)
+      FooApp.stack(:foo,      :labels => [:production, :demo] ).use(FooMiddle)
+      FooApp.stack(:bar,      :labels => [:test]              ).use(BarMiddle)
+      FooApp.stack(:baz,      :labels => [:any]               ).use(BazMiddle)
+    end
+
+    it "should differentiate between stack types" do
+      FooApp.middlewares(:production).map{|m| m.middleware}.should == [GeneralMiddleware, FooMiddle, BazMiddle]
+      FooApp.middlewares(:demo).map{|m| m.middleware}.should == [FooMiddle, BazMiddle]
+      FooApp.middlewares(:test).map{|m| m.middleware}.should == [BarMiddle, BazMiddle]
+      FooApp.middlewares(:demo, :test).map{|m| m.middleware}.should == [FooMiddle, BarMiddle,BazMiddle]
+    end
+
+    it "should add a middleware that is not declared with any particular label to all stacks" do
+      class PazMiddle < GeneralMiddleware; end
+      FooApp.stack(:paz).use(PazMiddle)
+      FooApp.middlewares(:test).map{|m| m.middleware}.should == [BarMiddle, BazMiddle, PazMiddle]
+      FooApp.middlewares(:demo).map{|m| m.middleware}.should == [FooMiddle, BazMiddle, PazMiddle]
+      FooApp.middlewares(:production).map{|m| m.middleware}.should == [GeneralMiddleware, FooMiddle, BazMiddle, PazMiddle]
+    end
+
+    it "should not use a middleware if it is dependent on middleware that is not in the correct stack" do
+      class PazMiddle < GeneralMiddleware; end
+      FooApp.stack(:paz, :after => :bar).use(PazMiddle)
+      FooApp.middlewares(:production).map{|m| m.middleware}.should == [GeneralMiddleware, FooMiddle, BazMiddle]
+      FooApp.middlewares(:test).map{|m| m.middleware}.should == [BarMiddle, PazMiddle, BazMiddle]
+    end
+  end
+end