waw 0.2.2

data/test/unit/waw/controllers/action_test.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+require 'waw'
+module Waw
+  module Controllers
+    class ActionController < ::Waw::Controller
+      class ActionTest < Test::Unit::TestCase
+        
+        class A < ::Waw::ActionController
+          
+          signature{}
+          def hello(params)
+          end
+          
+          def self.url
+            "/services"
+          end
+          def url
+            "/services"
+          end
+          
+        end
+        
+        def test_id
+          assert_equal "services_hello", A.hello.id
+        end
+        
+        def test_href
+          assert_equal "/services/hello", A.hello.href
+          assert_equal "/services/hello?who=blambeau", A.hello.href(:who => 'blambeau')
+        end
+        
+      end
+    end
+  end
+end

data/test/unit/waw/controllers/example_action_controller_test.rb

@@ -0,0 +1,24 @@
+require 'waw'
+require 'test/unit'
+module Waw
+  module Controllers
+    class ExampleActionControllerTest < Test::Unit::TestCase
+      
+      class A < ::Waw::ActionController
+        
+        signature {}
+        def say_hello(params)
+          :ok
+        end
+        
+      end
+      
+      def test_show_what_happened
+        assert A.respond_to?(:say_hello)
+        assert ::Waw::ActionController::Action === A.say_hello
+        assert_equal [:success, :ok], A.instance.say_hello({})
+      end
+      
+    end
+  end
+end

data/test/unit/waw/controllers/multiple_action_controller_test.rb

@@ -0,0 +1,78 @@
+require 'waw'
+require 'test/unit'
+module Waw
+  module Controllers
+    class MultipleActionControllerTest < Test::Unit::TestCase
+      class A < ::Waw::ActionController
+        signature {}
+        def action_1(params)
+          "A.action_1"
+        end
+        signature {}
+        def action_2(params)
+          "A.action_2"
+        end
+      end
+      class B < ::Waw::ActionController
+        signature {}
+        def action_1(params)
+          "B.action_1"
+        end
+        signature {}
+        def action_3(params)
+          "B.action_3"
+        end
+      end
+      
+      def test_controllers
+        assert [A, B].all?{|c| ::Waw::ActionController.controllers.include?(c)}
+        assert A.controllers.object_id==::Waw::ActionController.controllers.object_id
+        assert B.controllers.object_id==::Waw::ActionController.controllers.object_id
+        assert A.controllers.object_id==B.controllers.object_id
+      end
+      
+      def test_actions
+        assert_equal 2, A.actions.size
+        assert_equal 2, B.actions.size
+        assert_equal [:action_1, :action_2], A.actions.keys.sort{|k1,k2| k1.to_s <=> k2.to_s}
+        assert_equal [:action_1, :action_3], B.actions.keys.sort{|k1,k2| k1.to_s <=> k2.to_s}
+        assert A.actions.object_id != B.actions.object_id
+      end
+      
+      def test_has_action?
+        assert A.has_action?(:action_1)
+        assert A.has_action?(:action_2)
+        assert !A.has_action?(:action_3)
+        assert B.has_action?(:action_1)
+        assert !B.has_action?(:action_2)
+        assert B.has_action?(:action_3)
+      end
+      
+      def test_find_action
+        assert ::Waw::ActionController::Action===A.find_action(:action_1)
+        assert ::Waw::ActionController::Action===A.find_action(:action_2)
+        assert_nil A.find_action(:action_3)
+        assert ::Waw::ActionController::Action===B.find_action(:action_1)
+        assert ::Waw::ActionController::Action===B.find_action(:action_3)
+        assert_nil B.find_action(:action_2)
+      end
+      
+      def test_find_action_on_instance
+        assert ::Waw::ActionController::Action===A.instance.find_action(:action_1)
+        assert ::Waw::ActionController::Action===A.instance.find_action(:action_2)
+        assert_nil A.instance.find_action(:action_3)
+        assert ::Waw::ActionController::Action===B.instance.find_action(:action_1)
+        assert ::Waw::ActionController::Action===B.instance.find_action(:action_3)
+        assert_nil B.instance.find_action(:action_2)
+      end
+      
+      def test_action_execution
+        assert_equal [:success, "A.action_1"], A[:action_1].execute
+        assert_equal [:success, "A.action_2"], A[:action_2].execute
+        assert_equal [:success, "B.action_1"], B[:action_1].execute
+        assert_equal [:success, "B.action_3"], B[:action_3].execute
+      end
+      
+    end
+  end
+end

data/test/unit/waw/controllers/static/example/css/example.css

@@ -0,0 +1 @@
+/* example.css */

data/test/unit/waw/controllers/static/example/index.html

@@ -0,0 +1 @@
+/* index.html */

data/test/unit/waw/controllers/static/example/js/example.js

@@ -0,0 +1 @@
+/* example.js */

data/test/unit/waw/controllers/static/example/pages/hello.wtpl

@@ -0,0 +1 @@
+Hello +{who}

data/test/unit/waw/controllers/static/waw_access_test.rb

@@ -0,0 +1,76 @@
+require 'test/unit'
+require 'waw'
+module Waw
+  class StaticController < ::Waw::Controller
+    # Waw version of .htaccess files
+    class WawAccessTest < Test::Unit::TestCase
+      
+      FIRST_WAW_ACCESS = <<-EOF
+        wawaccess do 
+          strategy :allow_all
+          match '.wtpl' do
+            {:message => 'serving .wtpl'}
+          end
+        end
+      EOF
+      
+      SECOND_WAW_ACCESS = <<-EOF
+        wawaccess do 
+          match '.html' do
+            {:message => 'serving .html'}
+          end
+          match '.brick' do
+            {:message => 'serving .brick'}
+          end
+        end
+      EOF
+      
+      def test_dsl
+        first = WawAccess.new(nil, nil).dsl_merge(FIRST_WAW_ACCESS)
+        second = WawAccess.new(nil, nil).dsl_merge(SECOND_WAW_ACCESS)
+        
+        first.folder = "/home"
+        second.folder = "/home/css"
+        second.parent = first
+        assert_nil first.parent
+        assert_equal "", first.identifier(false)
+        assert_equal ".wawaccess", first.identifier(true)
+        assert_equal "css/.wawaccess", second.identifier
+        assert_equal first, first.root
+        assert_equal first, second.root
+      end
+      
+      def test_find_wawaccess_for
+        wawaccess = WawAccess.load_hierarchy(File.join(File.dirname(__FILE__), 'example'))
+        assert_equal '.wawaccess', wawaccess.find_wawaccess_for('/').identifier
+        assert_equal '.wawaccess', wawaccess.find_wawaccess_for('/index.html').identifier
+        assert_equal '.wawaccess', wawaccess.find_wawaccess_for('/unexisting').identifier
+        assert_equal 'css/.wawaccess', wawaccess.find_wawaccess_for('/css').identifier
+        assert_equal 'css/.wawaccess', wawaccess.find_wawaccess_for('css').identifier
+        assert_equal 'css/.wawaccess', wawaccess.find_wawaccess_for('/css/example.css').identifier
+        assert_equal 'js/.wawaccess', wawaccess.find_wawaccess_for('/js/example.js').identifier
+        assert_equal 'pages/.wawaccess', wawaccess.find_wawaccess_for('/pages').identifier
+        assert_equal 'pages/.wawaccess', wawaccess.find_wawaccess_for('/pages/').identifier
+        assert_equal 'pages/.wawaccess', wawaccess.find_wawaccess_for('/pages/hello.wtpl').identifier
+      end
+      
+      def assert_successfull_serve(what, content=nil, msg = "#{what} is sucessfully served")
+        status, headers, value = what
+        value = value.join("\n") if Array===value
+        contenttype = headers['Content-Type']
+        assert_equal(200, status, msg)
+        assert_equal(content, value) if content
+      end
+      
+      def test_on_example
+        wawaccess = WawAccess.load_hierarchy(File.join(File.dirname(__FILE__), 'example'))
+        assert WawAccess===wawaccess
+        # assert_successfull_serve wawaccess.do_path_serve('/css/example.css'), "/* example.css */"
+        assert_successfull_serve wawaccess.do_path_serve('/'), "Hello blambeau"
+        # assert_successfull_serve wawaccess.do_path_serve('/hello.wtpl'), "Hello blambeau"
+        # assert_successfull_serve wawaccess.do_path_serve('/pages/hello.wtpl'), "Hello blambeau"
+      end
+      
+    end
+  end
+end

data/test/unit/waw/ext/rack_test.rb

@@ -0,0 +1,74 @@
+require 'waw'
+require 'test/unit'
+module Waw
+  class RackExtensionTest < Test::Unit::TestCase
+    
+    class AnApp
+      include Rack::Delegator
+      def initialize(name)
+        @name = name
+      end
+      def to_s
+        "#{self.class}('#{@name}')"
+      end
+    end
+    
+    # Creates a typical rack application under @app
+    def setup
+      @app1 = AnApp.new('/')
+      @app2 = AnApp.new('/webserv/event')
+      @app3 = AnApp.new('/webserv/people')
+      @urlmap2 = ::Rack::URLMap.new(
+        '/event' => @app2,
+        '/people' => @app3 
+      )
+      @json = ::Waw::JSONController.new(@urlmap2)
+      @urlmap1 = ::Rack::URLMap.new(
+        '/' => @app1,
+        '/webserv' => @json
+      )
+      @session = ::Rack::Session::Pool.new(@urlmap1, :domain => "www.waw.org", :expire_after => 65)
+      @logger = ::Rack::CommonLogger.new(@session, STDOUT)
+      @restart = ::Waw::Restart.new(@logger)
+      @app = ::Waw::Kern::App.new
+      @app.app = @restart
+    end
+    
+    def test_find_rack_app
+      app = @app
+      assert_equal @app1, app.find_rack_app('/')
+      assert_equal @app1, app.find_rack_app('/'){|theapp| AnApp===theapp}
+      assert ::Waw::JSONController===app.find_rack_app('/webserv')
+      assert_equal @app2, app.find_rack_app('/webserv/event'){|theapp| AnApp===theapp}
+      assert_equal @app2, app.find_rack_app('/webserv/event/and_an_action_name'){|theapp| AnApp===theapp}
+      assert_equal @app3, app.find_rack_app('/webserv/people'){|theapp| AnApp===theapp}
+      assert_equal @app3, app.find_rack_app('/webserv/people/and_an_action_name'){|theapp| AnApp===theapp}
+      assert_equal @logger, app.find_rack_app{|theapp| ::Rack::CommonLogger===theapp}
+      assert_equal @json, app.find_rack_app{|theapp| ::Waw::JSONController===theapp}
+    end
+    
+    def test_find_url_of
+      assert_equal '/', @app.find_url_of(@app)
+      [@logger, @session, @urlmap1, @app1].each {|app| assert_equal '/', @app.find_url_of(app)}
+      [@json, @urlmap2].each{|app| assert_equal '/webserv', @app.find_url_of(app)}
+      [@app2].each{|app| assert_equal '/webserv/event', @app.find_url_of(app)}
+      [@app3].each{|app| assert_equal '/webserv/people', @app.find_url_of(app)}
+      assert_equal nil, @app.find_url_of(self)
+    end
+    
+    def test_visit
+      paths = Hash.new{|h,k| h[k] = []}
+      @app.visit{|path, app| 
+        paths[path] << app
+      }
+      expected = {
+        '/' => [@app, @restart, @logger, @session, @urlmap1, @app1],
+        '/webserv' => [@json, @urlmap2],
+        '/webserv/event' => [@app2],
+        '/webserv/people' => [@app3]
+      }
+      assert_equal expected, paths
+    end
+    
+  end
+end

data/test/unit/waw/resource_collection_test.rb

@@ -0,0 +1,49 @@
+require 'waw'
+require 'test/unit'
+module Waw
+  class ResourceCollectionTest < Test::Unit::TestCase
+    
+    class Trash
+      def self.write(*args) end
+      def self.close(*args) end
+    end
+    def setup
+      Waw.logger = Logger.new(Trash)
+    end
+    
+    def test_resources_on_string
+      r = ResourceCollection.parse_resources <<-EOF
+        first_one  "Hello world"
+        second_one 2
+        third_one 2*33
+      EOF
+      assert r.has_resource?(:first_one)
+      assert_equal "Hello world", r.first_one
+      assert_equal "Hello world", r[:first_one]
+      assert_equal 2, r.second_one
+      assert_equal 66, r.third_one
+      assert !r.has_resource?(:missing)
+    end
+    
+    def test_resources_on_file
+      r = ResourceCollection.parse_resource_file(File.join(File.dirname(__FILE__), 'resources.txt'))
+      assert r.has_resource?(:first_one)
+      assert_equal "Hello world", r.first_one
+      assert_equal "Hello world", r[:first_one]
+      assert_equal 2, r.second_one
+      assert_equal 66, r.third_one
+      assert !r.has_resource?(:missing)
+    end
+    
+    def test_on_missing_resources
+      r = ResourceCollection.parse_resources <<-EOF
+        first_one  "Hello world"
+        second_one 2
+        third_one 2*33
+      EOF
+      assert_equal nil, r.hello
+      assert_equal "world", r.hello("world")
+    end
+    
+  end
+end

data/test/unit/waw/resources.txt

@@ -0,0 +1,4 @@
+first_one  "Hello world"
+second_one 2
+# nothing expected here
+third_one 2*33

data/test/unit/waw/routing/routing_test.rb

@@ -0,0 +1,26 @@
+require 'test/unit'
+require 'waw'
+module Waw
+  class RoutingTest < Test::Unit::TestCase
+    include Waw::Routing::Methods
+    
+    def test_installation_on_routing_itself
+      result = ["success", "ok"]
+      assert Routing.matches?("success/ok", result)
+      assert Routing.matches?("success/*", result)
+      result = ["success", ["ok"]]
+      assert Routing.matches?("success/ok", result)
+      assert Routing.matches?("success/*", result)
+    end
+    
+    def test_matches
+      result = ["success", "ok"]
+      assert matches?("success/ok", result)
+      assert matches?("success/*", result)
+      result = ["success", ["ok"]]
+      assert matches?("success/ok", result)
+      assert matches?("success/*", result)
+    end
+    
+  end
+end

data/test/unit/waw/utils/dsl_helper_test.rb

@@ -0,0 +1,79 @@
+require 'test/unit'
+require 'waw/utils/dsl_helper'
+
+# Tests the DSLHelper class
+class DSLHelperTest < Test::Unit::TestCase
+  
+  # Ensures an expanded path on a test-relative file
+  def relative(file)
+    File.join(File.dirname(__FILE__), file)
+  end
+  
+  # Tests some test hypotheses
+  def test_hypotheses
+    assert_equal true, String.method_defined?(:upcase)
+    assert_equal false, String.method_defined?(:a_method_that_doesnt_exists)
+  end
+  
+  # Tests DSLHelper.is_intrusive?
+  def test_is_intrusive?
+    assert_equal true, DSLHelper.is_intrusive?(String => [:upcase])
+    assert_equal true, DSLHelper.is_intrusive?(String => [:upcase, :a_method_that_doesnt_exists])
+    assert_equal false, DSLHelper.is_intrusive?(String => [:a_method_that_doesnt_exists])
+    assert_equal true, DSLHelper.is_intrusive?(String => [:upcase], DSLHelperTest => [:test_hypotheses])
+    assert_equal true, DSLHelper.is_intrusive?(String => [:a_method_that_doesnt_exists], DSLHelperTest => [:test_hypotheses])
+    assert_equal false, DSLHelper.is_intrusive?(String => [:a_method_that_doesnt_exists], DSLHelperTest => [:a_method_that_doesnt_exists])
+  end
+  
+  # Tests DSLHelper.find_instance_method
+  def test_find_instance_method
+    assert_not_nil DSLHelper.find_instance_method(String, :upcase)
+    assert_nil DSLHelper.find_instance_method(String, :a_method_that_doesnt_exists)
+  end
+  
+  # Tests dry usage of the class
+  def test_dry_usage
+    DSLHelper.new(String => [:upcase, :downcase]) do 
+      Kernel.load relative('dsl_helper_test_extensions1.rb')
+      assert_equal "hello", "hello".upcase
+      assert_equal "HELLO", "HELLO".downcase
+    end
+    assert_equal "HELLO", "hello".upcase
+    assert_equal "hello", "HELLO".downcase
+  end
+  
+  # Tests normal usage of the class
+  def test_normal_usage
+    helper = DSLHelper.new(String => [:upcase, :downcase])
+    2.times do
+      helper.save
+        Kernel.load relative('dsl_helper_test_extensions1.rb')
+        assert_equal "hello", "hello".upcase
+        assert_equal "HELLO", "HELLO".downcase
+      helper.restore
+      assert_equal "HELLO", "hello".upcase
+      assert_equal "hello", "HELLO".downcase
+    end
+  end
+  
+  # Tests that bad usage leads to friendly errors
+  def test_it_handles_bad_usage_friendly
+    helper = DSLHelper.new(String => [:upcase, :downcase])
+    assert_nothing_raised do helper.save end
+    assert_raise RuntimeError do helper.save end
+    assert_nothing_raised do helper.restore end
+  end
+  
+  # Tests stability of usage errors
+  def test_it_is_stable_to_usage_errors
+    helper = DSLHelper.new(String => [:upcase, :downcase])
+    helper.save
+    Kernel.load relative('dsl_helper_test_extensions1.rb')
+    assert_equal "hello", "hello".upcase
+    assert_raise RuntimeError do helper.save end
+    assert_equal "hello", "hello".upcase
+    assert_nothing_raised do helper.restore end
+    assert_equal "HELLO", "hello".upcase
+  end
+  
+end