hassox-pancake 0.1.6

data/spec/pancake/mime_types_spec.rb

@@ -0,0 +1,234 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "..", "spec_helper")
+
+describe Pancake::MimeTypes do
+  before do
+    Pancake::MimeTypes.reset!
+  end
+  
+  it "should have many types" do
+    Pancake::MimeTypes.types.should be_an(Array)
+  end
+
+  it "should have a type for each mime type defined in Rack::Mime::MIME_TYPES" do
+    Rack::Mime::MIME_TYPES.each do |ext, type|
+      ext =~ /\.(.*)$/
+      t = Pancake::MimeTypes.type_by_extension($1)
+      t.should_not be_nil
+      t.should be_an_instance_of(Pancake::MimeTypes::Type)
+      t.type_strings.should include(type)
+    end
+  end
+
+  it "should find the type from an extension" do
+    t = Pancake::MimeTypes.type_by_extension("html")
+    t.should_not be_nil
+    t.type_strings.should include("text/html")
+  end
+  
+  it "should allow me to add a new mime type" do
+    t = Pancake::MimeTypes::Type.new("foo", "text/foobar")
+    type = Pancake::MimeTypes.type_by_extension("foo")
+    type.should_not be_nil
+    type.type_strings.should have(1).item
+    type.type_strings.should include("text/foobar")
+  end
+  
+  describe Pancake::MimeTypes::Type do
+    include Pancake::MimeTypes
+
+    before do
+      @type = Pancake::MimeTypes::Type.new("html", "text/html")
+    end
+    
+    it "should have one extension" do
+      @type.extension.should == "html"
+    end
+    
+    it "should tell me the type strings" do
+      @type.type_strings.should include("text/html")
+    end
+
+    it "should allow me to add type strings" do
+      @type.type_strings << "text/foo_html"
+      @type.type_strings.should include("text/foo_html")
+    end
+
+    it "should not add duplicate type strings" do
+      @type.type_strings.should have(1).item
+      @type.type_strings << "text/html"
+      @type.type_strings.should have(2).items
+      @type.type_strings.should include("text/html")
+    end
+
+    it "should add non duplicate tpe strying" do
+      @type.type_strings.should have(1).item
+      @type.type_strings << "text/foo_html"
+      @type.type_strings.should have(2).items
+      @type.type_strings.should include("text/foo_html")
+    end
+  end
+
+  describe "grouping types" do
+    it "should allow me to create a group of mime types" do
+      Pancake::MimeTypes.group(:html).should be_an(Enumerable)
+    end
+
+    it "should allow me to add mime types to the group" do
+      Pancake::MimeTypes.group_as(:foo, "html", "xhtml")
+      r = Pancake::MimeTypes.group(:foo)
+      r.should have(2).items
+      r.should include(Pancake::MimeTypes.type_by_extension("html"))
+      r.should include(Pancake::MimeTypes.type_by_extension("xhtml"))
+    end
+
+    it "should allow me to add to a group without creating duplicates" do
+      t = Pancake::MimeTypes::Type.new("foo", "foo/bar")
+      Pancake::MimeTypes.group_as(:bar, "xhtml", "html")
+      Pancake::MimeTypes.group(:bar).should have(2).items
+      Pancake::MimeTypes.group(:bar).should_not include(t)
+      Pancake::MimeTypes.group_as(:bar, "html", "foo", "xhtml")
+      Pancake::MimeTypes.group(:bar).should have(3).items
+      Pancake::MimeTypes.group(:bar).should include(t)
+    end
+    
+    it "should allow me to look up a mime type via a string or symbol identifier" do
+      Pancake::MimeTypes.group(:html).should eql Pancake::MimeTypes.group("html")
+    end
+    
+    it "should be empty empty when accessing a non existant mime type" do
+      r = Pancake::MimeTypes.group(:not_a_mime)
+      r.should_not be_nil
+      r.should be_empty
+      r.should respond_to(:each)
+    end
+    
+    it "should populate the group with the types when first acessing when a type with that extension exists" do
+      r = Pancake::MimeTypes.group(:xml)
+      r.should_not be_empty
+      r.each do |t|
+        t.should be_an_instance_of(Pancake::MimeTypes::Type)
+      end
+    end
+  end
+
+  describe "prepared groups" do
+    it "should prepare the html group" do
+      g = Pancake::MimeTypes.group(:html)
+      g.should have(3).items
+      ["html", "htm", "xhtml"].each do |ext|
+        t = Pancake::MimeTypes.type_by_extension(ext)
+        g.should include(t)
+      end
+    end
+    
+    it "should parepare the text group" do
+      g = Pancake::MimeTypes.group(:text)
+      g.should have(2).items
+      ["text", "txt"].each do |ext|
+        t = Pancake::MimeTypes.type_by_extension(ext)
+        g.should include(t)
+      end
+    end
+
+    it "should prepare the svg group" do
+      g = Pancake::MimeTypes.group(:svg)
+      g.should have(2).items
+      ["svg", "svgz"].each do |ext|
+        t = Pancake::MimeTypes.type_by_extension(ext)
+        g.should include(t)
+      end
+    end
+    
+    
+    it "should add the text/xml to the xml format" do
+      t = Pancake::MimeTypes.type_by_extension("xml")
+      t.type_strings.should include("text/xml", "application/xml")
+    end
+  end
+  
+  describe "format from accept type" do
+    it "should return the first matching type" do
+      accept_type = "text/plain"
+      group, at, r = Pancake::MimeTypes.negotiate_accept_type(accept_type, :text)
+      group.should == :text
+      at.should == accept_type
+      r.should_not be_nil
+      r.type_strings.should include("text/plain")
+    end
+    
+    it "should return the first type if the matching type is */*" do
+      accept_type = "*/*;application/xml"
+      group, at, r = Pancake::MimeTypes.negotiate_accept_type(accept_type, :text, :xml, :html)
+      at.should == "text/plain"
+      group.should == :text
+      r.should_not be_nil
+      r.type_strings.should include("text/plain")
+    end
+
+    it "should use */* if avaiable" do
+      # safari uses application/xml first
+      accept_type = "application/xml,*/*"
+      group, at, r = Pancake::MimeTypes.negotiate_accept_type(accept_type, :html, :xml)
+      at.should == "text/html"
+      group.should == :html
+      r.should_not be_nil
+    end
+    
+    it "should return nil if there is no matching class" do
+      accept_type = "text/xml"
+      group, r = Pancake::MimeTypes.negotiate_accept_type(accept_type, :text, :html)
+      r.should be_nil
+      group.should be_nil
+    end
+    
+    it "should return a type when it is not in the first position" do
+      accept_type = "text/xml, text/html,text/plain;"
+      group, at, r = Pancake::MimeTypes.negotiate_accept_type(accept_type, :svg, :text)
+      group.should == :text
+      r.should_not be_nil
+      r.type_strings.should include("text/plain")
+      r.extension.should == "text"
+    end
+
+    it "should recognize the type from a quality value" do
+      accept_type = "text/plain;q=0.5,text/html;q=0.8"
+      group, at,  r = Pancake::MimeTypes.negotiate_accept_type(accept_type, :text, :html)
+      group.should == :html
+      r.should_not be_nil
+      r.type_strings.should include("text/html")
+      r.extension.should == "html"
+    end
+  end
+
+  describe "mime from extension" do
+    it "should recognize the mime type from the extension" do
+      group, at, r = Pancake::MimeTypes.negotiate_by_extension("text", :html, :text)
+      group.should == :text
+      at.should == "text/plain"
+      r.should == Pancake::MimeTypes.type_by_extension("text")
+    end
+
+    it "should recognize grouped mimes by extension" do
+      Pancake::MimeTypes.group_as(:foo, "text", "txt", "html")
+      group, at, r = Pancake::MimeTypes.negotiate_by_extension("txt", :foo)
+      group.should == :foo
+      at.should == "text/plain"
+      r.extension.should == "txt"
+      group, at, r = Pancake::MimeTypes.negotiate_by_extension("text", :foo)
+      r.extension.should == "text"
+      group, at, r = Pancake::MimeTypes.negotiate_by_extension("html", :foo)
+      r.extension.should == "html"
+      at.should == "text/html"
+    end
+
+    it "should not negotiate by extension when there the extension is not part of the accepted types" do
+      Pancake::MimeTypes.group_as(:bar, "text")
+      group, at, r = Pancake::MimeTypes.negotiate_by_extension("svg", :bar)
+      group.should be_nil
+      at.should be_nil
+      r.should be_nil
+    end
+    
+  end
+end
+

data/spec/pancake/mixins/publish_spec.rb

@@ -0,0 +1,94 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe "Pancake::Controller publish declaration" do
+  before(:each) do
+    class ::PancakeTest
+      extend Pancake::Mixins::Publish
+      
+      provides :html
+      
+      publish
+      def simple_publish; end
+      
+      publish :id => as(:integer)
+      def integer_test; end
+      
+      publish :start => as(:date)
+      def date_test; end
+      
+      publish :page => as(:integer, 12)
+      def default_test; end
+      
+      publish :provides => [:xml, :json]
+      def provides_test; end
+      
+      publish :only_provides => :xml
+      def only_provides_test; end
+      
+      publish :name => as(:string, :opt)
+      def optional_test; end
+      
+      publish :provides => [:json, :txt],
+              :id       => as(:integer, :req), 
+              :name     => as(:string, "Campion"), 
+              :melon    => as(:integer, 50),
+              :jam      => as(:string, :opt),
+              :squeeze  => as(:string, :req)
+      def complex_test; end
+    end
+  end
+  
+  after do 
+    clear_constants "PancakeTest"
+  end
+  
+  it "should publish an action" do
+    PancakeTest.actions['simple_publish'].is_a?(Pancake::Mixins::Publish::ActionOptions).should == true
+  end
+  
+  it "should coerce a parameter into an integer" do
+    params, missing = PancakeTest.__send__(:validate_and_coerce_params, 'integer_test', 'id' => "30")
+    params['id'].should == 30
+  end
+  
+  it "should coerce a parameter into a date" do
+    date = Date.parse("2009/07/05")
+    params, missing = PancakeTest.__send__(:validate_and_coerce_params, 'date_test', 'start' => "2009/07/05")
+    params['start'].should == date
+  end
+  
+  it "should flag required params that are missing" do
+    params, missing = PancakeTest.__send__(:validate_and_coerce_params, 'integer_test', {})
+    missing.include?(['id', :integer]).should == true
+  end
+  
+  it "should allow parameters to be optional" do
+    params, missing = PancakeTest.__send__(:validate_and_coerce_params, 'optional_test', {})
+    missing.empty?.should == true
+  end
+  
+  it "should return a default value for a parameter" do
+    params, missing = PancakeTest.__send__(:validate_and_coerce_params, 'default_test', {})
+    params['page'].should == 12
+  end
+  
+  it "should append formats to the list allowed for an action" do
+    PancakeTest.actions['provides_test'].formats.should == [:html, :xml, :json]
+  end
+  
+  it "should replace the list of formats allowed for an action" do
+    PancakeTest.actions['only_provides_test'].formats.should == [:xml]
+  end
+  
+  it "should allow complex declarations" do
+    input = {'id' => "30", 'name' => "Purslane"}
+    params, missing = PancakeTest.__send__(:validate_and_coerce_params, 'complex_test', input)
+    params['id'].should == 30
+    params['name'].should == "Purslane"
+    params['melon'].should == 50
+    params['jame'].should be_nil
+    missing.include?(['squeeze', :string]).should == true
+    
+    PancakeTest.actions['complex_test'].formats.should == [:html, :json, :txt]
+  end
+end

data/spec/pancake/mixins/render_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Pancake::Mixins::Render do
+  before do
+    class ::RenderSpecClass
+      include Pancake::Mixins::Render
+      
+      # setup the renderer
+      roots << File.expand_path(File.join(File.dirname(__FILE__), "..", "fixtures", "render_templates"))
+      push_paths :views, "/", "**/*"
+      
+      def params
+        @params ||= {}
+      end
+      
+      def string
+        render :text => "A String"
+      end
+      
+      def the_current_context
+        "the current context"
+      end
+    end
+    
+    @render = RenderSpecClass.new
+  end
+  after do
+    clear_constants "RenderSpecClass"
+  end
+  
+  it "should allow me to render a string" do
+    @render.string.should == "A String"
+  end
+  
+  it "should render a haml" do
+    @render.render(:haml_template).chomp.should == "IN HAML"
+  end
+  
+  it "should render erb" do
+    @render.render(:erb_template).should == "IN ERB"
+  end
+  
+  it "should render an xml format" do
+    @render.render(:haml_template, :format => :xml).chomp.should == "IN HAML XML"
+  end
+  
+  it "should render an erb template for json" do
+    @render.render(:erb_template, :format => :json).chomp.should == "IN ERB JSON"
+  end
+  
+  it "should render with the rendering controller as the current context" do
+    @render.render(:context_template).chomp.should == "the current context"
+  end
+  
+end

data/spec/pancake/mixins/stack_helper_spec.rb

@@ -0,0 +1,46 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "..","..","spec_helper")
+
+describe Pancake::Mixins::StackHelper do
+  before do
+    class ::FooStack < Pancake::Stack
+      class Bar
+        include Pancake::Mixins::StackHelper
+      end
+    end
+  end
+
+  after do
+    clear_constants :FooStack, :BarStack, :FooBar
+  end
+
+  it "should provide access to the stack helper to the Bar class" do
+    FooStack::Bar.stack_class.should == FooStack
+  end
+
+  it "should track the class for a newly namespaced stack" do
+    class ::BarStack < FooStack
+      class Bar < ::FooStack::Bar
+      end
+    end
+
+    BarStack::Bar.stack_class.should == BarStack
+  end
+
+  it "should raise an exception when including it into a class that is not of a stack" do
+    lambda do
+      class ::FooBar
+        include Pancake::Mixins::StackHelper
+      end
+    end.should raise_error
+  end
+
+  it "should remember the stack it was initially mixed into if it's inherited to a non namespaced class" do
+    class ::FooBar < FooStack::Bar; end
+    FooBar.stack_class.should == FooStack
+  end
+  
+  it "should provide access to the stack helper from an instance of the Bar class" do
+    FooStack::Bar.new.stack_class.should == FooStack
+  end
+  
+end

data/spec/pancake/pancake_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "pancake" do
+  
+  it "should get the correct root directory for a file" do
+    Pancake.get_root(__FILE__).should == File.expand_path(File.dirname(__FILE__))
+  end
+  
+  describe "stack labels" do
+    before(:each) do 
+      @orig_lables = Pancake.stack_labels
+    end
+
+    after(:each) do
+      Pancake.stack_labels = @orig_labels
+    end
+
+    it "should allow me to set a stack type on panckae" do
+      Pancake.stack_labels = [:foo, :bar]
+      Pancake.stack_labels.should == [:foo, :bar]
+    end
+  
+    it "should provide me with stack label of [:production] by default" do
+      Pancake.stack_labels = nil
+      Pancake.stack_labels.should == [:production]
+      Pancake.stack_labels = []
+      Pancake.stack_labels.should == [:production]
+    end
+  end
+  
+end