hassox-pancake 0.1.6

data/spec/pancake/paths_spec.rb

@@ -0,0 +1,210 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Pancake::Paths do
+  
+  def fixture_root
+    File.expand_path(File.join(File.dirname(__FILE__), "fixtures", "paths"))
+  end
+  
+  before(:each) do
+    remove_consts!
+    class ::Foo
+      extend Pancake::Paths
+    end
+  end
+  
+  after(:all) do
+    remove_consts!
+  end
+  
+  def remove_consts!
+    Object.class_eval do 
+      remove_const("Foo") if defined?(Foo)
+      remove_const("Bar") if defined?(Bar)
+      remove_const("Baz") if defined?(Baz)
+    end
+  end
+  
+  describe "setting roots" do
+    it "should allow me to set roots" do
+      Foo.roots.should == []
+      Foo.roots << fixture_root
+      Foo.roots.should == [fixture_root]
+    end
+  end
+  
+  describe "pushing paths" do
+    before do
+      Foo.roots << fixture_root
+    end
+    
+    it "should push a single path" do
+      Foo.push_paths(:models, "models")
+      Foo.dirs_for(:models).should == [File.join(fixture_root,"models")]
+    end
+    
+    it "should give me an empty array of paths when there have been no paths added" do
+      Foo.dirs_for(:models).should == []
+    end
+    
+    it "should raise and error if there are no paths specified" do
+      lambda do
+        Foo.push_paths(:models)
+      end.should raise_error(ArgumentError)
+      
+      lambda do
+        Foo.push_paths(:models, [])
+      end.should raise_error(Pancake::Paths::NoPathsGiven)
+    end
+    
+    it "should allow me to push multiple times to a single path group" do
+      Foo.push_paths(:models, "models")
+      Foo.push_paths(:models, "stack/models")
+      Foo.dirs_for(:models).should == [
+        File.join(fixture_root, "models"),
+        File.join(fixture_root, "stack", "models")
+      ]
+    end
+    
+    it "should allow me to push multiple path sets" do
+      Foo.push_paths(:models,      ["models", "stack/models"])
+      Foo.push_paths(:controllers, "controllers")
+      Foo.push_paths(:views,       "stack/views")
+      Foo.dirs_for(:models).should == [
+        File.join(fixture_root, "models"),
+        File.join(fixture_root, "stack", "models")
+      ]
+      Foo.dirs_for(:controllers ).should == [File.join(fixture_root, "controllers")]
+      Foo.dirs_for(:views       ).should == [File.join(fixture_root, "stack", "views")]
+    end
+    
+    it "should reverse the dirs_for when specified" do
+      Foo.push_paths(:models,      ["models", "stack/models"])
+      Foo.dirs_for(:models, :invert => true).should == [
+        File.join(fixture_root, "stack", "models"),
+        File.join(fixture_root, "models")
+      ]
+    end
+    
+    describe "globs" do
+      it "should allow me to supply a glob to associate with the path" do
+        Foo.push_paths(:models,  "models",        "**/*.rb")
+        Foo.push_paths(:models,  "stack/models",  "**/*.rb")
+        Foo.dirs_and_glob_for(:models).should == [
+          [File.join(fixture_root, "models"),           "**/*.rb"],
+          [File.join(fixture_root, "stack", "models"),  "**/*.rb"]
+        ]
+      end
+      
+      it "should associate an empty glob when not specified" do
+        Foo.push_paths(:models, "foo/bar")
+        Foo.dirs_for(:models).should == [File.join(fixture_root, "foo/bar")]
+        Foo.dirs_and_glob_for(:models).should == [[File.join(fixture_root, "foo/bar"), nil]]
+      end
+      
+      it "should revers the dirs_and_globs when requested" do
+        Foo.push_paths(:models,  "models",      "**/*.rb")
+        Foo.push_paths(:models,  "stack/models", "**/*.rb")
+        result = Foo.dirs_and_glob_for(:models, :invert => true)
+        result.should == [
+          [File.join(fixture_root, "stack", "models"),  "**/*.rb"],
+          [File.join(fixture_root, "models"),           "**/*.rb"]
+        ]
+      end
+    end
+  end
+  
+  describe "reading paths" do
+    before(:each) do
+      @model_root = File.join(fixture_root, "models")
+      @stack_root =  File.join(fixture_root, "stack/models")
+      Foo.roots << fixture_root
+      Foo.push_paths(:model, ["models", "stack/models"], "**/*.rb")
+    end
+    
+    it "should have list all the paths for :model" do
+      result = Foo.paths_for(:model).should == [
+        [@model_root, "/model1.rb"],
+        [@model_root, "/model2.rb"],
+        [@model_root, "/model3.rb"],
+        [@stack_root, "/model3.rb"]
+      ]
+    end
+    
+    it "should allow me to invert the order of the roots" do
+      result = Foo.paths_for(:model, :invert => true).should == [
+        [@stack_root, "/model3.rb"],
+        [@model_root, "/model3.rb"],
+        [@model_root, "/model2.rb"],
+        [@model_root, "/model1.rb"]
+      ]
+    end
+    
+    it "should allow me to get the unique_paths" do
+      result = Foo.unique_paths_for(:model).should == [
+        [@model_root, "/model1.rb"],
+        [@model_root, "/model2.rb"],
+        [@stack_root, "/model3.rb"]
+      ]
+    end
+    
+    it "should allow me to invert the order of the unique_paths" do
+      result = Foo.unique_paths_for(:model, :invert => true).should == [
+        [@model_root, "/model3.rb"],
+        [@model_root, "/model2.rb"],
+        [@model_root, "/model1.rb"]
+      ]
+    end
+  end
+  
+  describe "inherited paths" do
+    before(:each) do
+      Foo.push_paths(:model,      "models")
+      Foo.push_paths(:controller, "controllers")
+      Foo.roots << fixture_root
+      class ::Bar < Foo; end
+    end
+    
+    it "should inherit paths from the parent" do
+      Bar.dirs_for(:model).should       == [File.join(fixture_root, "models")]
+      Bar.dirs_for(:controller).should  == [File.join(fixture_root, "controllers")]
+    end
+    
+    it "should let me add to the collection from the parent" do
+      Bar.push_paths(:model, "stack/models")
+      Bar.dirs_for(:model).should == [
+        File.join(fixture_root, "models"),
+        File.join(fixture_root, "stack/models")
+      ]
+    end
+    
+    it "should not bleed paths back up to the parent" do
+      Bar.push_paths(:model, "stack/models")
+      Foo.dirs_for(:model).should == [File.join(fixture_root, "models")]
+    end
+    
+    it "should not bleed paths over to a sibling class" do
+      class ::Baz < Foo; end
+      Bar.push_paths(:model, "stack/models")
+      Baz.push_paths(:model, "baz/paths")
+      Bar.dirs_for(:model).should == [
+        File.join(fixture_root, "models"),
+        File.join(fixture_root, "stack/models")
+      ]
+      Baz.dirs_for(:model).should == [
+        File.join(fixture_root, "models"),
+        File.join(fixture_root, "baz/paths")
+      ]
+      Foo.dirs_for(:model).should == [File.join(fixture_root, "models")]
+    end
+    
+    it "should inherit multpile times" do
+      class ::Baz < Bar; end
+      Bar.push_paths(:model, "bar/path")
+      Baz.dirs_for(:model).should == [
+        File.join(fixture_root, "models"),
+        File.join(fixture_root, "bar/path")
+      ]
+    end
+  end
+end

data/spec/pancake/stack/app_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "Pancake::Stack.new_app_instance" do
+  
+  before(:each) do
+    class ::FooStack < Pancake::Stack
+      
+    end
+  end
+  
+  after(:each) do
+    clear_constants(:FooStack)
+  end
+  
+  it "should provide a new instance of the applciation" do
+    FooStack.new_app_instance.should == Pancake::MISSING_APP
+  end
+  
+  it "should allow me to overwrite the new_app_instance for this stack" do
+    class ::BarStack < Pancake::Stack
+      def self.new_app_instance
+        ::Pancake::OK_APP
+      end
+    end
+    
+    BarStack.new_app_instance.should == ::Pancake::OK_APP
+  end
+end

data/spec/pancake/stack/bootloader_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "Stack BootLoaders" do
+  
+  before(:each) do
+    clear_constants(:FooStack, :BarStack)
+  end
+  
+  it "should inherit the standard bootloaders from Pancake::Stack" do
+    class ::FooStack < Pancake::Stack; end
+    FooStack::BootLoader.should inherit_from(Pancake::Stack::BootLoader)
+  end
+  
+  it "should get all the bootloaders from pancake stack" do
+    class ::FooStack < Pancake::Stack; end
+    FooStack::BootLoader.map{|n,bl|n}.should == Pancake::Stack::BootLoader.map{|n,bl|n}
+  end
+  
+  it "should let FooStack define it's own bootloaders" do
+    class ::FooStack < Pancake::Stack; end
+    FooStack::BootLoader.add(:foo_stack_bootloader){ def run!; end }
+    FooStack::BootLoader.map{|n,b|n}.should include(:foo_stack_bootloader)
+    Pancake::Stack::BootLoader.map{|n,b|n}.should_not include(:foo_stack_bootloader)
+  end
+  
+  it "should not pollute other bootloaders" do
+    class ::FooStack < Pancake::Stack; end
+    FooStack::BootLoader.add(:foo_stack_bootloader){ def run!; end }
+    class ::BarStack < Pancake::Stack; end
+    FooStack::BootLoader.map{|n,b|n}.should_not == BarStack::BootLoader.map{|n,b|n}
+    BarStack::BootLoader.map{|n,b|n}.should_not include(:foo_stack_bootloader)
+  end
+  
+  it "should inherit custom bootloaders" do
+    class ::FooStack < Pancake::Stack; end
+    FooStack::BootLoader.add(:foo_stack_bootloader){ def run!; end }
+    class ::BarStack < FooStack; end
+    BarStack::BootLoader.map{|n,b|n}.should include(:foo_stack_bootloader)
+  end
+
+end

data/spec/pancake/stack/router_spec.rb

@@ -0,0 +1,266 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "stack router" do
+  before(:all) do
+    clear_constants "FooApp" ,"INNER_APP", "BarApp", "InnerApp", "InnerFoo", "InnerBar"
+  end
+  before(:each) do
+
+    ::INNER_APP = Proc.new{ |e|
+      [
+        200,
+        {"Content-Type" => "text/plain"},
+        [
+          JSON.generate({
+            "SCRIPT_NAME" => e["SCRIPT_NAME"],
+            "PATH_INFO"   => e["PATH_INFO"],
+            "usher.params" => e["usher.params"]
+          })
+        ]
+      ]
+    }
+    class ::FooApp < Pancake::Stack; end
+    FooApp.roots << Pancake.get_root(__FILE__)
+  end
+
+  after(:each) do
+    clear_constants "FooApp" ,"INNER_APP", "BarApp"
+  end
+
+  def app
+    @app
+  end
+
+  describe "mount" do
+    it "should let me setup routes for the stack" do
+      FooApp.router do |r|
+        r.mount(INNER_APP, "/foo", :_defaults => {:action => "foo action"}).name(:foo)
+        r.mount(INNER_APP, "/bar", :_defaults => {:action => "bar action"}).name(:root)
+      end
+
+      @app = FooApp.stackup
+      expected = {
+        "SCRIPT_NAME" => "/foo",
+        "PATH_INFO"   => "",
+        "usher.params" => {"action" => "foo action"}
+      }
+
+      get "/foo"
+      JSON.parse(last_response.body).should == expected
+    end
+
+    it "should allow me to stop the route from partially matching" do
+        FooApp.with_router do |r|
+          r.mount(INNER_APP, "/foo/bar", :_defaults => {:action => "foo/bar"}, :_exact => true).name(:foobar)
+        end
+        @app = FooApp.stackup
+        expected = {
+          "SCRIPT_NAME"   => "/foo/bar",
+          "PATH_INFO"     => "",
+          "usher.params"  => {"action" => "foo/bar"}
+        }
+        get "/foo/bar"
+        JSON.parse(last_response.body).should == expected
+        get "/foo"
+        last_response.status.should == 404
+    end
+
+    it "should make sure that the application is a rack application" do
+      lambda do
+        FooApp.router.mount(:not_an_app, "/foo")
+      end.should raise_error(Pancake::Router::RackApplicationExpected)
+    end
+  end
+
+  describe "generating routes" do
+    before do
+      FooApp.router do |r|
+        r.add("/simple/route"    ).name(:simple)
+        r.add("/var/with/:var", :_defaults => {:var => "some_var"}).name(:defaults)
+        r.add("/complex/:var"    ).name(:complex)
+        r.add("/optional(/:var)" ).name(:optional)
+        r.add("/some/:unique_var")
+      end
+    end
+
+    it "should allow me to generate a named route for a stack" do
+      Pancake.url(FooApp, :simple).should == "/simple/route"
+    end
+
+    it "should allow me to generate a non-named route for a stack" do
+      Pancake.url(FooApp, :complex, :var => "a_variable").should == "/complex/a_variable"
+    end
+
+    it "should allow me to generate a route with values" do
+      Pancake.url(FooApp, :optional).should == "/optional"
+      Pancake.url(FooApp, :optional, :var => "some_var").should == "/optional/some_var"
+    end
+
+    it "should allow me to generate routes with defaults" do
+      Pancake.url(FooApp, :defaults).should == "/var/with/some_var"
+      Pancake.url(FooApp, :defaults, :var => "this_is_a_var").should == "/var/with/this_is_a_var"
+    end
+
+    it "should allow me to generate a route by params" do
+      Pancake.url(FooApp, :unique_var => "unique_var").should == "/some/unique_var"
+    end
+
+    describe "mounted route generation" do
+      before do
+        class ::BarApp < Pancake::Stack; end
+        BarApp.roots << Pancake.get_root(__FILE__)
+        BarApp.router do |r|
+          r.add("/simple").name(:simple)
+          r.add("/some/:var", :_defaults => {:var => "foo"}).name(:foo)
+        end
+        FooApp.router.mount(BarApp.stackup, "/bar")
+      end
+
+      it "should allow me to generate a simple nested named route" do
+        Pancake.url(BarApp, :simple).should == "/bar/simple"
+      end
+
+      it "should allow me to generate a simple nested named route for a named app" do
+        FooApp.router.mount(BarApp.stackup(:app_name => :bar_app), "/different")
+        Pancake.url(:bar_app, :simple).should == "/different/simple"
+        Pancake.url(BarApp,   :simple).should == "/bar/simple"
+      end
+    end
+
+  end
+
+  describe "internal stack routes" do
+    it "should pass through to the underlying app when adding a route" do
+      FooApp.router.add("/bar", :_defaults => {:action => "bar"}).name(:gary)
+      class ::FooApp
+        def self.new_app_instance
+          INNER_APP
+        end
+      end
+
+      @app = FooApp.stackup
+      get "/bar"
+      result = JSON.parse(last_response.body)
+      result["usher.params"].should == {"action" => "bar"}
+    end
+
+    it "should add the usher.params to the request params" do
+      app = mock("app", :call => Rack::Response.new("OK").finish, :null_object => true)
+      app.should_receive(:call).with do |e|
+        params = Rack::Request.new(e).params
+        params[:action].should == "jackson"
+      end
+      FooApp.router.mount(app, "/foo/app", :_defaults => {:action => "jackson"})
+      @app = FooApp.stackup
+      get "/foo/app"
+    end
+  end
+
+  it "should allow me to inherit routes" do
+    FooApp.router do |r|
+      r.mount(INNER_APP, "/foo(/:stuff)", :_defaults => {"originator" => "FooApp"})
+    end
+    class ::BarApp < FooApp; end
+    BarApp.router do |r|
+      r.mount(INNER_APP, "/bar", :_defaults => {"originator" => "BarApp"})
+    end
+
+    @app = BarApp.stackup
+
+    get "/bar"
+    response = JSON.parse(last_response.body)
+    response["usher.params"]["originator"].should == "BarApp"
+
+    get "/foo/thing"
+    response = JSON.parse(last_response.body)
+    response["usher.params"]["originator"].should == "FooApp"
+  end
+
+  it "should generate an inherited route" do
+    FooApp.router do |r|
+      r.add("/simple").name(:simple)
+      r.mount(INNER_APP, "/foo(/:stuff)").name(:stuff)
+    end
+
+    class ::BarApp < FooApp; end
+
+    Pancake.url(BarApp, :simple).should == "/simple"
+    Pancake.url(BarApp, :stuff => "this_stuff").should == "/foo/this_stuff"
+    Pancake.url(BarApp, :stuff, :stuff => "that_stuff").should == "/foo/that_stuff"
+  end
+
+  it "should put the configuration into the env" do
+    FooApp.router.add("/foo").to do |e|
+      e["pancake.request.configuration"].should == Pancake.configuration.configs[FooApp]
+      Rack::Response.new("OK").finish
+    end
+    @app = FooApp.stackup
+    get "/foo"
+  end
+  
+  describe "generating urls inside an application" do
+    before do
+      class ::BarApp < FooApp;  end
+      
+      class ::InnerApp
+        attr_reader :env
+        include Pancake::Mixins::RequestHelper
+
+        def self.app_block(&block)
+          if block_given?
+            @app_block = block
+          end
+          @app_block
+        end
+        
+        def call(env)
+          @env = env
+          instance_eval &self.class.app_block
+          Rack::Response.new("OK").finish
+        end
+      end
+
+      class ::FooApp; def self.new_app_instance; InnerApp.new; end; end
+            
+      BarApp.router do |r|
+        r.add("/mounted")
+        r.add("/foo").name(:foo)
+        r.add("/other").name(:other)
+      end
+
+      FooApp.router do |r|
+        r.mount(BarApp.stackup, "/bar")
+        r.add(  "/foo"   ).name(:foo)
+        r.add(  "/simple").name(:simple)
+      end
+
+      @app = FooApp.stackup
+    end
+
+    it "should generate the urls correctly" do
+      InnerApp.app_block do
+        url(:foo).should == "/foo"
+        url(:simple).should == "/simple"
+      end
+      
+      get "/foo"
+    end
+
+    it "should generate urls correctly when nested" do
+      InnerApp.app_block do
+        url(:foo).should == "/bar/foo"
+        url(:other).should == "/bar/other"
+      end
+      get "/bar/mounted"
+    end
+
+    it "should generate a url for another app" do
+      InnerApp.app_block do
+        url_for(BarApp, :foo).should == "/bar/foo"
+        url_for(FooApp, :foo).should == "/foo"
+      end
+      get "/foo"
+    end
+    
+  end
+end