merb-core 0.9.2

data/spec/public/directory_structure/directory/merb.4000.pid

@@ -0,0 +1 @@
+7315

data/spec/public/directory_structure/directory_spec.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
+Merb.start :environment => 'test',
+           :merb_root => File.dirname(__FILE__) / "directory"
+
+describe "The default Merb directory structure" do
+
+  it "should load in controllers" do
+    calling { Base }.should_not raise_error
+  end
+
+  it "should be able to complete the dispatch cycle" do
+    controller = dispatch_to(Base, :string)
+    controller.body.should == "String"
+  end
+
+  it "should be able to complete the dispatch cycle with templates" do
+    controller = dispatch_to(Base, :template)
+    controller.body.should == "Template ERB"
+  end
+
+end
+
+describe "Modifying the _template_path" do
+
+  it "should move the templates to a new location" do
+    controller = dispatch_to(Custom, :template)
+    controller.body.should == "Wonderful Template"
+  end
+
+end
+
+describe "Merb.root_path" do
+
+  it "should return a path relative to Merb.root" do
+    path = Merb.root_path('/app/controllers/base.rb')
+    path.should == File.join(Merb.root, '/app/controllers/base.rb')
+  end
+
+  it "should accept multiple arguments like File.join" do
+    path = Merb.root_path('app', 'controllers', 'base.rb')
+    path.should == File.join(Merb.root, 'app', 'controllers', 'base.rb')
+  end
+
+end

data/spec/public/logger/logger_spec.rb

@@ -0,0 +1,175 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Merb do
+
+  describe "Command Line Options" do
+    
+    it "should allow -l / --log_level to set the log_level" do
+      pending("How do we spec these?")
+    end
+    
+    it "should allow -L / --log_file  to set the log_file" do
+      pending("How do we spec these?")
+      # Run an instance of merb from the command line 
+      # using system and test if the file was created?
+    end
+    
+  end
+
+end
+
+describe Merb::Logger do
+
+  describe "#new" do
+    it "should call set_log with the arguments it was passed." do
+      pending("How do we catch an initialize in a spec?")
+      # Merb::Logger.should_receive(:set_log).with(Merb.log_file).and_return(true)
+      # Merb::Logger.new(Merb.log_file)
+    end
+  end
+  
+  describe "#set_log" do
+
+    before(:each) do
+      @logger = Merb::Logger.new(Merb.log_file)
+    end
+
+    it "should set the log level to :warn (4) when second parameter is :warn" do
+      Merb::Logger.new(Merb.log_file, :warn).level.should eql(4)
+    end
+
+    it "should set the log level to :debug (0) when Merb.environment is development" do
+      Merb.should_receive(:environment).twice.and_return("development")
+      @logger.set_log(Merb.log_path / "development.log")
+      @logger.level.should eql(0)
+    end
+    
+    it "should set the log level to :error (6) when Merb.environment is production" do
+      Merb.should_receive(:environment).twice.and_return("production")
+      @logger.set_log(Merb.log_path / "production.log")
+      @logger.level.should eql(4)
+    end
+    
+    it "should initialize the buffer to an empty array" do
+      @logger.buffer.should eql([])
+    end
+
+    it "should default the delimiter to ' ~ '" do
+      @logger.delimiter.should eql(" ~ ")
+    end
+    
+    it "should assign the newly created object to Merb.logger" do
+      @logger = Merb::Logger.new(Merb.log_file)
+      Merb.logger.should eql(@logger)
+    end
+    
+  end
+  
+  describe "#flush" do
+
+    before(:each) do
+      @logger = Merb::Logger.new(Merb.log_file)
+    end
+    
+    it "should immediately return if the buffer is empty" do
+      @logger.should_not_receive(:write_method)
+      @logger.flush
+    end
+
+    it "should call the write_method with the stringified contents of the buffer if the buffer is non-empty" do
+      @logger.send(:<<, "a message")
+      @logger.send(:<<, "another message")
+      @logger.log.should_receive(:write_method).with(" ~ a message\n ~ another message\n")
+      @logger.flush
+    end
+
+  end
+  
+  describe "#close" do
+    before(:each) do
+      @logger = Merb::Logger.new(Merb.log_file)
+    end
+
+    it "should flush the buffer before closing" do
+      # TODO: how to specify order? eg. flush then close
+      @logger.should_receive(:flush)
+      @logger.log.should_receive(:close)
+      @logger.close
+    end
+
+    it "should call the close method if the log responds to close" do
+      @logger.log.should_receive(:close)
+      @logger.close
+    end
+
+    it "should set the stored log attribute to nil" do
+      @logger.close
+      @logger.log.should eql(nil)
+    end
+
+  end
+
+  describe "<<" do
+    
+  end
+
+  describe "level methods" do
+
+    before(:all) do
+      @logger = Merb::Logger.new(Merb.log_file)
+    end
+
+    it "should provide a #debug method which can be used to log" do
+      @logger.should respond_to(:debug)
+      @logger.should_receive(:<<).with("message").and_return(true)
+      @logger.debug("message")
+    end
+
+    it "should provide a #info method which can be used to log" do
+      @logger.should respond_to(:info)
+      @logger.should_receive(:<<).with("message").and_return(true)
+      @logger.info("message")
+    end
+
+    it "should provide a #warn method which can be used to log" do
+      @logger.should respond_to(:warn)
+      @logger.should_receive(:<<).with("message").and_return(true)
+      @logger.warn("message")
+    end
+
+    it "should provide a #error method which can be used to log" do
+      @logger.should respond_to(:error)
+      @logger.should_receive(:<<).with("message").and_return(true)
+      @logger.error("message")
+    end
+
+    it "should provide a #fatal method which can be used to log" do
+      @logger.should respond_to(:fatal)
+      @logger.should_receive(:<<).with("message").and_return(true)
+      @logger.fatal("message")
+    end
+    
+    # TODO: add positive and negative tests for each of the methods below:
+    it "should provide a #debug? method" do
+      @logger.should respond_to(:debug?)
+    end
+
+    it "should provide a #info? method" do
+      @logger.should respond_to(:info?)
+    end
+
+    it "should provide a #warn? method" do
+      @logger.should respond_to(:warn?)
+    end
+
+    it "should provide a #error? method" do
+      @logger.should respond_to(:error?)
+    end
+
+    it "should provide a #fatal? method" do
+      @logger.should respond_to(:fatal?)
+    end
+
+  end
+
+end

data/spec/public/logger/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")

data/spec/public/reloading/directory/app/controllers/application.rb

@@ -0,0 +1,3 @@
+
+
+class Application < Merb::Controller; end

data/spec/public/reloading/directory/app/controllers/reload.rb

@@ -0,0 +1,6 @@
+        
+        class Reloader < Application
+        end
+
+        class Hello < Application
+        end

data/spec/public/reloading/directory/config/init.rb

@@ -0,0 +1,2 @@
+Merb::Config[:reload_classes] = true
+Merb::Config[:reload_time] = 0.5

data/spec/public/reloading/directory/log/merb.4000.pid

@@ -0,0 +1 @@
+6618

data/spec/public/reloading/directory/log/merb_test.log

@@ -0,0 +1,59 @@
+Thu, 14 Feb 2008 17:24:16 GMT  ~  info  ~  Logfile created
+Thu, 14 Feb 2008 17:24:16 GMT ~ Not Using Sessions
+Thu, 14 Feb 2008 17:32:11 GMT ~ Not Using Sessions
+Thu, 14 Feb 2008 17:34:04 GMT ~ Not Using Sessions
+Thu, 14 Feb 2008 17:56:43 GMT ~ Not Using Sessions
+Thu, 14 Feb 2008 17:57:29 GMT ~ Not Using Sessions
+Thu, 14 Feb 2008 17:58:17 GMT ~ Not Using Sessions
+Thu, 14 Feb 2008 21:20:41 GMT ~ Not Using Sessions
+Fri, 15 Feb 2008 18:44:39 GMT ~ Not Using Sessions
+Sun, 17 Feb 2008 15:32:32 GMT ~ Not Using Sessions
+Sun, 17 Feb 2008 16:12:02 GMT ~ Not Using Sessions
+Sun, 17 Feb 2008 16:21:37 GMT ~ Not Using Sessions
+Mon, 25 Feb 2008 23:09:52 GMT ~ Not Using Sessions
+Mon, 25 Feb 2008 23:11:49 GMT ~ Not Using Sessions
+Mon, 25 Feb 2008 23:13:22 GMT ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions
+ ~ Not Using Sessions

data/spec/public/reloading/directory/merb.4000.pid

@@ -0,0 +1 @@
+7319

data/spec/public/reloading/reload_spec.rb

@@ -0,0 +1,80 @@
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
+Merb.start :environment => 'test',
+           :merb_root => File.dirname(__FILE__) / "directory"
+           
+describe "The reloader" do
+
+  def reload!
+    Merb::BootLoader::ReloadClasses.reload
+  end
+  
+  before :all do
+    @reload_file = File.dirname(__FILE__) / "directory" / "app" / "controllers" / "reload.rb"
+    File.open(@reload_file, "w") do |f|
+      @text = <<-END
+        
+        class Reloader < Application
+        end
+
+        class Hello < Application
+        end
+      END
+      f.puts @text
+    end
+    
+    sleep 0.6
+  end
+  
+  it "should reload files that were changed" do
+    defined?(Hello).should_not be_nil
+    defined?(Reloader).should_not be_nil
+    defined?(Reloader2).should be_nil
+    
+    sleep 0.6
+    
+    File.open(@reload_file, "w") do |f|
+      f.puts <<-END
+        
+        class Reloader < Application
+        end
+
+        class Reloader2
+        end
+      END
+    end
+
+    sleep 0.6
+    
+    defined?(Hello).should be_nil
+    defined?(Reloader).should_not be_nil
+    defined?(Reloader2).should_not be_nil
+  end
+  
+  it "should remove classes for _abstract_subclasses" do
+    File.open(@reload_file, "w") do |f|
+      f.puts <<-END
+        
+        class Reloader < Application
+        end
+
+        class Reloader2 < Application
+        end
+      END
+    end
+    
+    sleep 0.6
+    
+    Merb::AbstractController._abstract_subclasses.should include("Reloader")
+    Merb::AbstractController._abstract_subclasses.should include("Reloader2")    
+    defined?(Hello).should be_nil
+    defined?(Reloader).should_not be_nil
+    defined?(Reloader2).should_not be_nil    
+  end
+  
+  after :each do
+    sleep 0.6
+    File.open(@reload_file, "w") do |f|
+      f.puts @text
+    end
+  end
+end

data/spec/public/request/multipart_spec.rb

@@ -0,0 +1,15 @@
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
+require "mongrel"
+
+describe Merb::Request do
+  it "should handle file upload for multipart/form-data posts" do
+    file = Struct.new(:read, :filename, :path).
+      new("This is a text file with some small content in it.", "sample.txt", "sample.txt")
+    m = Merb::Test::MultipartRequestHelper::Post.new :file => file
+    body, head = m.to_multipart
+    request = fake_request({:request_method => "POST", :content_type => head, :content_length => body.length}, :req => body)
+    request.params[:file].should_not be_nil
+    request.params[:file][:tempfile].class.should == Tempfile
+    request.params[:file][:content_type].should == 'text/plain'
+  end
+end

data/spec/public/request/request_spec.rb

@@ -0,0 +1,207 @@
+require File.join(File.dirname(__FILE__), "..", "..", "spec_helper")
+require "mongrel"
+
+describe Merb::Request, "#method" do
+  
+  [:get, :head, :put, :delete].each do |method|
+    it "should use the HTTP if it was a #{method.to_s.upcase}" do
+      fake_request(:request_method => method.to_s).method.should == method
+    end
+
+    it "should use the _method body params for #{method.to_s.upcase} when it came in as a POST" do
+      request = fake_request({:request_method => "POST"}, :post_body => "_method=#{method}")
+      request.method.should == method
+    end
+    
+    it "should use the _method query params for #{method.to_s.upcase} when it came in as a POST" do
+      Merb::Request.parse_multipart_params = false
+      request = fake_request(:request_method => "POST", :query_string => "_method=#{method}")
+      request.method.should == method      
+    end
+    
+    [:get, :head, :put, :delete].each do |meth|
+      it "should return #{method == meth} when calling #{meth}? and the method is :#{method}" do
+        request = fake_request({:request_method => method.to_s})
+        request.send("#{meth}?").should == (method == meth)
+      end
+    end
+  end
+
+  it "should default to POST if the _method is not defined" do
+    request = fake_request({:request_method => "POST"}, :post_body => "_method=zed")
+    request.method.should == :post
+  end
+  
+  it "should raise an error if an unknown method is used" do
+    request = fake_request({:request_method => "foo"})
+    running {request.method}.should raise_error
+  end
+    
+end
+
+describe Merb::Request, " query and body params" do
+  
+  before(:all) { Merb::BootLoader::Dependencies.enable_json_gem }
+  
+  {"foo=bar&baz=bat"        => {"foo" => "bar", "baz" => "bat"},
+   "foo[]=bar&foo[]=baz"    => {"foo" => ["bar", "baz"]},
+   "foo[1]=bar&foo[2]=baz"  => {"foo" => {"1" => "bar", "2" => "baz"}}}.each do |query, parse|
+
+     it "should convert #{query.inspect} to #{parse.inspect} in the query string" do
+       request = fake_request({:query_string => query})
+       request.stub!(:route_params).and_return({})       
+       request.params.should == parse
+     end
+
+     it "should convert #{query.inspect} to #{parse.inspect} in the post body" do
+       request = fake_request({}, :post_body => query)
+       request.stub!(:route_params).and_return({})
+       request.params.should == parse
+     end
+   
+   end
+   
+  it "should support JSON params" do
+    request = fake_request({:content_type => "application/json"}, :req => %{{"foo": "bar"}})
+    request.stub!(:route_params).and_return({})
+    request.params.should == {"foo" => "bar"}
+  end
+
+  it "should support XML params" do
+    request = fake_request({:content_type => "application/xml"}, :req => %{<foo bar="baz"><baz/></foo>})
+    request.stub!(:route_params).and_return({})
+    request.params.should == {"foo" => {"baz" => nil, "bar" => "baz"}}
+  end  
+  
+end
+
+describe Merb::Request, "#remote_ip" do
+  it "should be able to get the remote IP of a request with X_FORWARDED_FOR" do
+    request = fake_request({:http_x_forwarded_for => "www.example.com"})
+    request.remote_ip.should == "www.example.com"
+  end
+  
+  it "should be able to get the remote IP when some of the X_FORWARDED_FOR are local" do
+    request = fake_request({:http_x_forwarded_for => "192.168.2.1,127.0.0.1,www.example.com"})
+    request.remote_ip.should == "www.example.com"
+  end
+  
+  it "should be able to get the remote IP when it's in REMOTE_ADDR" do
+    request = fake_request({:remote_addr => "www.example.com"})
+    request.remote_ip.should == "www.example.com"    
+  end
+end
+
+describe Merb::Request, "#cookies" do
+  
+  it "should take cookies in the HTTP_COOKIE environment variable" do
+    request = fake_request({:http_cookie => "merb=canhascookie; version=1"})
+    request.cookies.should == {"merb" => "canhascookie", "version" => "1"}
+  end
+  
+  it "should handle badly formatted cookies" do
+    request = fake_request({:http_cookie => "merb=; ; also=hats"})
+    request.cookies.should == {"merb" => "", "also" => "hats", "" => nil}
+  end
+  
+end
+
+describe Merb::Request, " misc" do
+  
+  it "should know if a request is an XHR" do
+    request = fake_request({:http_x_requested_with => "XMLHttpRequest"})
+    request.should be_xhr
+  end
+  
+  it "should know if the protocol is http or https (when HTTPS is on)" do
+    request = fake_request({:https => "on"})
+    request.protocol.should == "https://"
+    request.should be_ssl
+  end
+
+  it "should know if the protocol is http or https (when HTTP_X_FORWARDED_PROTO is https)" do
+    request = fake_request({:http_x_forwarded_proto => "https"})
+    request.protocol.should == "https://"
+    request.should be_ssl
+  end
+
+  it "should know if the protocol is http or https (when it's regular HTTP)" do
+    request = fake_request({})
+    request.protocol.should == "http://"
+  end
+  
+  it "should get the content-length" do
+    request = fake_request({:content_length => "300"})
+    request.content_length.should == 300
+  end
+  
+  it "should be able to get the path from the URI (stripping trailing /)" do
+    request = fake_request({:request_uri => "foo/bar/baz/?bat"})
+    request.path.should == "foo/bar/baz"
+  end
+  
+  it "should be able to get the path from the URI (joining multiple //)" do
+    request = fake_request({:request_uri => "foo/bar//baz/?bat"})
+    request.path.should == "foo/bar/baz"
+  end
+  
+  it "should get the remote port" do
+    request = fake_request({:server_port => "80"})
+    request.port.should == 80
+  end
+  
+  it "should get the parts of the remote subdomain" do
+    request = fake_request({:http_host => "zoo.boom.foo.com"})
+    request.subdomains.should == ["zoo", "boom"]
+  end
+  
+  it "should get the parts of the remote subdomain when there's an irregular TLD number" do
+    request = fake_request({:http_host => "foo.bar.co.uk"})
+    request.subdomains(2).should == ["foo"]
+  end
+  
+  it "should get the full domain (not including subdomains and not including the port)" do
+    request = fake_request({:http_host => "www.foo.com:80"})
+    request.domain.should == "foo.com"
+  end
+
+  it "should get the full domain from an irregular TLD" do
+    request = fake_request({:http_host => "www.foo.co.uk:80"})
+    request.domain(2).should == "foo.co.uk"
+  end
+
+  it "should get the host (with X_FORWARDED_HOST)" do
+    request = fake_request({:http_x_forwarded_host => "www.example.com"})
+    request.host.should == "www.example.com"
+  end
+
+  it "should get the host (without X_FORWARDED_HOST)" do
+    request = fake_request({:http_host => "www.example.com"})
+    request.host.should == "www.example.com"
+  end
+    
+  {:http_referer            => ["referer", "http://referer.com"],
+   :request_uri             => ["uri", "http://uri.com/uri"],
+   :http_user_agent         => ["user_agent", "mozilla"],
+   :server_name             => ["server_name", "apache"],
+   :http_accept_encoding    => ["accept_encoding", "application/json"],
+   :script_name             => ["script_name", "foo"],
+   :http_cache_control      => ["cache_control", "no-cache"],
+   :http_accept_language    => ["accept_language", "en"],
+   :server_software         => ["server_software", "apache"],
+   :http_keep_alive         => ["keep_alive", "300"],
+   :http_accept_charset     => ["accept_charset", "UTF-8"],
+   :http_version            => ["version", "1.1"],
+   :gateway_inteface        => ["gateway", "CGI/1.2"],
+   :http_connection         => ["connection", "keep-alive"],
+   :path_info               => ["path_info", "foo/bar/baz"],
+  }.each do |env, vars|
+    
+    it "should be able to get the #{env.to_s.upcase}" do
+      request = fake_request({env => vars[1]})
+      request.send(vars[0]).should == vars[1]
+    end
+    
+  end
+  
+end