pancake 0.1.8

data/spec/pancake/stack/router_spec.rb

@@ -0,0 +1,282 @@
+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
+
+
+    it "should not match a single segment route when only / is defined" do
+      FooApp.router.add("/", :_defaults => {:root => :var}) do |e|
+        Rack::Response.new("In the Root").finish
+      end
+      @app = FooApp.stackup
+      result = get "/not_a_route"
+      result.status.should == 404
+    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")
+        r.add("/", :_defaults => {:var => "root var"}).name(:root)
+      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
+
+  it "should inherit the router as an inherited inner class" do
+    class ::BarApp < FooApp; end
+    BarApp::Router.should inherit_from(FooApp::Router)
+  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

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,60 @@
+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
+
+    it "should allow me to set a root with a file" do
+      StackSpecStack.add_root(__FILE__)
+      StackSpecStack.roots.should include(Pancake.get_root(__FILE__))
+    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