fastr 0.0.3 → 0.1.0

data/lib/fastr/test/controller.rb

@@ -0,0 +1,78 @@
+require 'fastr/test/logger'
+require 'eventmachine'
+
+module Fastr
+  module Test
+    module Controller
+      def self.included(klass)
+        klass.extend(ClassMethods)
+        set_defaults(klass)
+      end
+      
+      # Sets up the test class.
+      def self.set_defaults(klass)
+        regex = Regexp.new(/^(\w+)ControllerTest$/)
+        match = regex.match(klass.to_s)
+        
+        if not match.nil?
+          klass.instance_variable_set(:@controller_class, match[1].to_s.uncamelcase)
+        end
+      end
+      
+      # Runs a test application.
+      #
+      # @param The code to run.
+      def run_test_app(&block)
+        EM.kqueue = true if EM.kqueue?
+        EM.epoll = true if EM.epoll?
+        EM.run do
+          app_path = Dir.pwd
+          app = Fastr::Test::Application.new(app_path)
+          app.boot
+          setup_dumb_router(app)
+          return block.call(app)
+        end
+      end
+      
+      # Sets up a router that has one route. We will always use / when calling dispatch.
+      def setup_dumb_router(app)
+        app.router.for '/', :to => "dummy#index"
+      end
+      
+      def get(action, options={})
+        make_request(:get, action, options)
+      end
+      
+      def post(action, options={})
+        make_request(:post, action, options)
+      end
+      
+      def make_request(method, action, options={})
+        run_test_app do |app|
+          env = {"PATH_INFO" => "/", "REQUEST_METHOD" => method.to_s.upcase}
+          case method
+          when :get then
+            env['QUERY_STRING'] = Fastr::HTTP.build_query_string(options[:params]) if options[:params]
+          when :post then
+            env['rack.input'] = StringIO.new(Fastr::HTTP.build_query_string(options[:params])) if options[:params]
+          end
+          
+          app.route = {:ok => {:controller => get_controller_class, :action => action}}
+          app.dispatch(env)
+        end
+      end
+      
+      def get_controller_class
+        klass = self.class.instance_variable_get(:@controller_class)
+        raise Exception.new("No controller set. Use set_controller.") if klass.nil?
+        return klass
+      end
+      
+      module ClassMethods
+        def set_controller(controller)
+          @controller_class = controller.to_s
+        end
+      end
+    end
+  end
+end

data/lib/fastr/test/logger.rb

@@ -0,0 +1,5 @@
+class Fastr::Log::Formatter
+  def call(severity, time, progname, msg)
+    #block all logging output during testing
+  end
+end

data/lib/fastr/test/tasks.rb

@@ -0,0 +1,3 @@
+Dir[File.join(File.dirname(__FILE__), 'tasks', '*.rake')].each do |f|
+  load f
+end

data/lib/fastr/test/tasks/test.rake

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.name = "fastr:test"
+  t.test_files = FileList['test/**/test_*.rb']
+  t.verbose = true
+end

data/test/fastr_app/app/config/settings.rb

@@ -0,0 +1 @@
+$fastr_settings_loaded = true

data/test/fastr_app/app/controllers/dispatch.rb

@@ -0,0 +1,31 @@
+class DispatchController < Fastr::Controller
+  def simple
+    [200, {"Content-Type" => "text/plain"}, ["success"]]
+  end
+  
+  def simple_header
+    self.headers['Test-Header'] = 'abc'
+    [200, {}, ["success"]]
+  end
+  
+  def render_header
+    self.headers['Test-Header'] = 'abc'
+    render(:text, "success")
+  end
+  
+  def test_get_params
+    [200, {}, [get_params, params]]
+  end
+  
+  def test_post_params
+    [200, {}, [post_params, params]]
+  end
+  
+  def test_controller_params
+    [200, {}, [[params[:controller], params[:action]]]]
+  end
+  
+  def test_cookies
+    [200, {}, [cookies]]
+  end
+end

data/test/helper.rb

@@ -21,19 +21,21 @@ end
 
 class ManualBootingApplication < Fastr::Application
   include Fastr::Log
-  
+
   def initialize(path)
     self.app_path = path
     self.plugins = []
+    self.settings = Fastr::Settings.new(self)
     @booting = true
   end
 end
 
 class Test::Unit::TestCase
-  def em_setup 
+  def em_setup(timeout = 0)
     EM.run do
+      EM.add_timer(timeout) { EM.stop }
       yield
-      EM.stop
+      EM.stop if timeout == 0
     end
   end
 end
@@ -43,4 +45,4 @@ class Fastr::Log::Formatter
     #block all logging output during testing
     #puts "[#{severity}] [#{self.progname}]: #{msg}"
   end
-end
+end

data/test/test_application.rb

@@ -1,21 +1,21 @@
 require 'helper'
 
 class TestApplication < Test::Unit::TestCase
-    
-  context "New Application" do  
+
+  context "New Application" do
     setup do
       em_setup{ @application = NueteredBootingApplication.new("/some/path") }
     end
-    
+
     should "store startup path" do
       assert_equal "/some/path",@application.app_path
     end
-    
+
     should "boot application" do
       assert @application.booted
     end
   end
-    
+
   context "Application Boot" do
     setup do
       em_setup {
@@ -23,17 +23,21 @@ class TestApplication < Test::Unit::TestCase
         @application.send(:boot).join
       }
     end
-  
+
+    should "load settings file" do
+      assert($fastr_settings_loaded)
+    end
+
     should "load app controllers" do
       assert defined?(FastrAppController)
     end
-    
+
     should "create router" do
       assert_not_nil @application.router
     end
-    
+
     should "setup routes from route file" do
       assert_equal 3,@application.router.routes.size
     end
   end
-end
+end

data/test/test_cookie.rb

@@ -0,0 +1,65 @@
+require 'helper'
+
+class TestCookie < Test::Unit::TestCase
+  include Fastr::Cookie
+
+  attr_accessor :headers
+
+  context "set cookies from controller" do
+    setup do
+      self.headers = {}
+    end
+
+    should "add cookie to array if header exists" do
+      self.headers["Set-Cookie"] = ['dummycookie']
+      set_cookie("key", "value")
+
+      assert_equal(2, self.headers['Set-Cookie'].length)
+    end
+
+    should "put cookie into array if no header exists" do
+      set_cookie("key", "value")
+
+      assert(self.headers['Set-Cookie'].kind_of? Array)
+      assert_equal(1, self.headers['Set-Cookie'].length)
+    end
+
+    should "set cookie key and value" do
+      set_cookie("key", "value")
+
+      hdr = self.headers['Set-Cookie']
+
+      assert_not_nil(hdr)
+      cookie = hdr[0]
+      assert_not_nil(cookie)
+      assert_equal(1, hdr.length)
+
+      assert_equal("key=value;", cookie)
+    end
+
+    should "add options into cookie" do
+      set_cookie("key", "value", {:a => 'b', :c => 'd'})
+
+      hdr = self.headers['Set-Cookie'][0]
+      assert_equal("key=value; a=b; c=d;", hdr)
+    end
+
+    should "add expires to cookie with correct format" do
+      time = Time.utc(2000, 1, 1, 0, 0, 0)
+
+      set_cookie("key", "value", {:expires => time})
+
+      hdr = self.headers['Set-Cookie'][0]
+      assert_equal("key=value; expires=Sat, 01-Jan-2000 00:00:00 GMT;", hdr)
+    end
+
+    should "add expires to cookie in utc if time is local" do
+      time = Time.utc(2000, 1, 1, 0, 0, 0).getlocal
+
+      set_cookie("key", "value", {:expires => time})
+
+      hdr = self.headers['Set-Cookie'][0]
+      assert_equal("key=value; expires=Sat, 01-Jan-2000 00:00:00 GMT;", hdr)
+    end
+  end
+end

data/test/test_deferrable.rb

@@ -1,7 +1,7 @@
 require 'helper'
 
 class TestDeferrable < Test::Unit::TestCase
-    
+
   context "Deferrable includer" do
     setup do
       @deferrable = DeferrableHost.new
@@ -23,11 +23,11 @@ class TestDeferrable < Test::Unit::TestCase
         end
       end
     end
-      
+
     should "pass sent data data through to server callback" do
-      assert_not_nil @deferrable.callbacks.index("hey\n") 
+      assert_not_nil @deferrable.callbacks.index("hey\n")
     end
-  
+
     should "run long task sent through response" do
       assert_not_nil @deferrable.callbacks.index("processing...\n")
     end
@@ -37,11 +37,11 @@ end
 class DeferrableHost
   include Fastr::Deferrable
   attr_accessor :callbacks
-  
+
   def initialize
     @callbacks = []
   end
-  
+
   def env
     {"async.callback"=>
       Proc.new{|array|
@@ -52,4 +52,4 @@ class DeferrableHost
       }
     }
   end
-end
+end

data/test/test_deferrable_response.rb

@@ -1,35 +1,35 @@
 require 'helper'
 
 class TestDeferrableResponse < Test::Unit::TestCase
-    
+
   context "DeferrableResponse" do
     setup do
       Fastr::Deferrable
       @response = Fastr::DeferrableResponse.new
     end
-    
+
     should "hold onto callback to push data through to" do
       @response.each {|data| assert_equal "Some Data",data }
       @response.send_data("Some Data")
     end
-      
+
     should "execute deferred tasks" do
       Object.expects(:touch!).times(2)
-      em_setup do
+      em_setup(2) do
         task = proc { Object.touch! }
         callback = proc { Object.touch! }
         @response.task(task,callback)
       end
     end
-    
+
     should "call success callback when told to finish" do
       callback_path = nil
-      em_setup do 
+      em_setup do
         @response.callback { callback_path = "success" }
         @response.errback { callback_path = "failure" }
-        @response.finish 
+        @response.finish
       end
       assert_equal "success",callback_path
     end
   end
-end
+end

data/test/test_dispatch.rb

@@ -0,0 +1,125 @@
+require 'helper'
+require 'mocha'
+
+class TestDispatch < Test::Unit::TestCase
+  include Fastr::Dispatch
+  include Fastr::Log
+
+  attr_accessor :plugins, :app
+
+  def method_missing(name, *args)
+    self.app.send(name, *args)
+  end
+
+  context "dispatching a request" do
+    setup do
+      self.plugins = []
+      em_setup do
+        self.app = NueteredBootingApplication.new(APP_PATH)
+        self.app.router = Fastr::Router.new(self.app)
+      end
+    end
+
+    should "return server not ready if booting" do
+      @booting = true
+
+      code, headers, body = *dispatch({})
+      assert_equal(500, code)
+      assert_equal({'Content-Type' => 'text/plain'}, headers)
+      assert_equal(["Server Not Ready"], body)
+    end
+
+    context "when doing dispatch" do
+      should "return static file if it exists" do
+        env = {"PATH_INFO" => "/static.txt"}
+        code, headers, body = *do_dispatch(env)
+        assert_equal(200, code)
+        assert_equal('text/plain', headers['Content-Type'])
+        assert_equal(['static'], body)
+      end
+
+      should "return 404 if no route exists" do
+        env = {"PATH_INFO" => "/some/invalid/route"}
+        code, headers, body = *do_dispatch(env)
+        assert_equal(404, code)
+        assert_equal('text/plain', headers['Content-Type'])
+        assert_equal(['404 Not Found: /some/invalid/route'], body)
+      end
+
+      context "and routing to a controller" do
+        should "return the response" do
+          env = {"PATH_INFO" => "/"}
+          self.app.router.for '/', :to => "dispatch#simple"
+          response = do_dispatch(env)
+          assert_equal([200, {"Content-Type" => "text/plain"}, ["success"]], response)
+        end
+
+        should "merge the controller's headers into the response" do
+          env = {"PATH_INFO" => "/"}
+          self.app.router.for '/', :to => "dispatch#simple_header"
+          code, headers, body = *do_dispatch(env)
+          assert_equal(200, code)
+          assert_equal('abc', headers['Test-Header'])
+          assert_equal(['success'], body)
+        end
+
+        should "set controller and action params" do
+          env = {"PATH_INFO" => "/"}
+          self.app.router.for '/', :to => "dispatch#test_controller_params"
+          code, headers, body = *do_dispatch(env)
+          assert_equal('dispatch', body[0][0])
+          assert_equal('test_controller_params', body[0][1])
+        end
+
+        should "set get params for a get request" do
+          env = {"PATH_INFO" => "/", "QUERY_STRING" => "a=b&c=d", "REQUEST_METHOD" => "GET"}
+          params = {'a' => 'b', 'c' => 'd'}
+          self.app.router.for '/', :to => "dispatch#test_get_params"
+          code, headers, body = *do_dispatch(env)
+          assert_equal(params, body[0])
+
+          params.each do |k,v|
+            assert(body[1].has_key? k)
+            assert(v, body[1][k])
+          end
+        end
+
+        should "set post params for a post request" do
+          env = {"PATH_INFO" => "/", "rack.input" => StringIO.new("a=b&c=d"), "REQUEST_METHOD" => "POST"}
+          params = {'a' => 'b', 'c' => 'd'}
+          self.app.router.for '/', :to => "dispatch#test_post_params"
+          code, headers, body = *do_dispatch(env)
+          assert_equal(params, body[0])
+
+          params.each do |k,v|
+            assert(body[1].has_key? k)
+            assert(v, body[1][k])
+          end
+        end
+
+        should "set cookies" do
+          env = {"PATH_INFO" => "/", "HTTP_COOKIE" => "a = b; c = d;", "REQUEST_METHOD" => "GET"}
+          cookies = {'a' => 'b', 'c' => 'd'}
+          self.app.router.for '/', :to => "dispatch#test_cookies"
+          code, headers, body = *do_dispatch(env)
+
+          cookies.each do |k,v|
+            assert(body[0].has_key? k)
+            assert(v, body[0][k])
+          end
+        end
+
+        should "preserve headers if render is called" do
+          env = {"PATH_INFO" => "/"}
+          self.app.router.for '/', :to => "dispatch#render_header"
+          code, headers, body = *do_dispatch(env)
+          assert_equal(200, code)
+          assert_equal('abc', headers['Test-Header'])
+          assert_equal(['success'], body)
+        end
+      end
+    end
+  end
+
+
+end