trinidad_jars 0.2.0 → 0.3.0.beta

data/README.rdoc

@@ -11,22 +11,42 @@ This project was initially called "Tomcat-rails" but due to legal issues with th
 
 == USAGE:
 
-  cd myrailsapp
-  jruby -S trinidad
-  
+Rails applications:
+
+    $ cd myrailsapp
+    $ jruby -S trinidad
+
+Rack applications:
+
+    $ cd myrackapplication
+
+    $ jruby -S trinidad -r path_to_rackup/rackup_file
+
+    or if the name of the file is config.ru
+
+    $ jruby -S trinidad -r path_to_rackup
+
+    or if config.ru is in the base directory
+
+    $ jruby -S trinidad -r
+
+    or if config.ru is under the directory WEB-INF
+
+    $ jruby -S trinidad
+
 == CONFIGURATION:
 
 Trinidad allows you to configure some parameters when the server is started from the command line, the following is a list of the currently supported options:
 
-  * -p, --port PORT         =>    port to bind to.
-  * -e, --env ENVIRONMENT   =>    rails environment.
-  * -c, --context CONTEXT   =>    application context path.
-  * --lib, --jars LIBS_DIR  =>    directory containing jars.
-  * --classes CLASSES_DIR   =>    directory containing classes.
-  * --rackup [RACKUP_FILE]  =>    run a provided rackup file instead of a rails application, by default it's config.ru.
-  * --public PUBLIC_DIR     =>    specify the public directory for your application, by default it's 'public'.
-  * -t, --threadsafe        =>    shortcut to work in threadsafe mode. Setting jruby_min_runtimes and jruby_max_runtimes to 1 in the configuration file the server behaves as the same way.
-  * -l, --load EXTENSION_NAME => loads an extension to use its command line options.
+  * -p, --port PORT             =>  port to bind to.
+  * -e, --env ENVIRONMENT       =>  rails environment.
+  * -c, --context CONTEXT       =>  application context path.
+  * --lib, --jars LIBS_DIR      =>  directory containing jars.
+  * --classes CLASSES_DIR       =>  directory containing classes.
+  * -r, --rackup [RACKUP_FILE]  =>  run a provided rackup file instead of a rails application, by default it's config.ru.
+  * --public PUBLIC_DIR         =>  specify the public directory for your application, by default it's 'public'.
+  * -t, --threadsafe            =>  shortcut to work in threadsafe mode. Setting jruby_min_runtimes and jruby_max_runtimes to 1 in the configuration file the server behaves as the same way.
+  * -l, --load EXTENSION_NAME   =>  loads an extension to use its command line options.
 
 The server can also be configured from a yaml file. If a file is not especified, the server tries to load the file <em>config/tomcat.yml</em>. Within this file you can add other options like jruby.min.runtimes(:jruby_min_runtimes) or jruby.max.runtimes(:jruby_max_runtimes).
 
@@ -44,6 +64,7 @@ From the version 0.8.0 Trinidad allows to extend the server with more Tomcat fea
 * Database connection pooling: http://github.com/calavera/trinidad-dbpool
 * Daemon, run Trinidad as a daemon: http://github.com/calavera/trinidad_daemon_extension
 * Hot deploy, do hot deploys monitorizing a temporal file, ala Passenger: http://github.com/calavera/trinidad_hotdeploy_extension
+* Sandbox, management console and REST api: http://github.com/calavera/trinidad_sandbox_extension
 
 You can find further information on how to write your own extension in the wiki: http://wiki.github.com/calavera/trinidad/extensions
 

data/lib/trinidad/jars.rb

@@ -5,9 +5,6 @@ $:.unshift(TRINIDAD_LIBS) unless
 module Trinidad
   require 'tomcat-core'
 
-  require 'jruby-rack'
-  require JRubyJars.jruby_rack_jar_path
-
   module Tomcat
     include_package 'org.apache.catalina'
     include_package 'org.apache.catalina.startup'

data/spec/fixtures/trinidad_foo_extension.rb

@@ -2,7 +2,7 @@ module Trinidad
   module Extensions
     class FooWebAppExtension < WebAppExtension
       def configure(tomcat, app_context)
-        @options
+        app_context.doc_base = 'foo_app_extension' if app_context
       end
     end
 

data/spec/trinidad/extensions_spec.rb

@@ -37,4 +37,22 @@ describe Trinidad::Extensions do
     extended = Trinidad::Extensions.configure_server_extensions(extensions, tomcat)
     extended.should_not equal(tomcat)
   end
+
+  it "ignores extensions that don't exist for that scope" do
+    extensions = {:override_tomcat => {}}
+    tomcat = Trinidad::Tomcat::Tomcat.new
+
+    lambda {
+      Trinidad::Extensions.configure_webapp_extensions(extensions, tomcat, nil)
+    }.should_not raise_error
+  end
+
+  it "raises an error when the extension doesn't exist" do
+    extensions = {:foo_bar => {}}
+    tomcat = Trinidad::Tomcat::Tomcat.new
+
+    lambda {
+      Trinidad::Extensions.configure_webapp_extensions(extensions, tomcat, nil)
+    }.should raise_error
+  end
 end

data/spec/trinidad/fakeapp.rb

@@ -17,8 +17,71 @@ EOF
 EOF
   end
 
+  def create_rails_web_xml
+    @rails_web_xml ||= config_file 'config/web.xml', <<-EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<web-app>
+    <servlet>
+        <servlet-name>RackServlet</servlet-name>
+        <servlet-class>org.jruby.rack.RackServlet</servlet-class>
+    </servlet>
+
+    <servlet-mapping>
+        <servlet-name>RackServlet</servlet-name>
+        <url-pattern>/*</url-pattern>
+    </servlet-mapping>
+
+    <listener>
+      <listener-class>org.jruby.rack.rails.RailsServletContextListener</listener-class>
+    </listener>
+
+</web-app>
+EOF
+  end
+
+  def create_rackup_web_xml
+    @rackup_web_xml ||= config_file 'config/web.xml', <<-EOF
+<?xml version="1.0" encoding="UTF-8"?>
+<web-app>
+    <context-param>
+      <param-name>jruby.min.runtimes</param-name>
+      <param-value>1<param-value>
+    </context-param>
+
+    <context-param>
+      <param-name>jruby.max.runtimes</param-name>
+      <param-value>1</param-value>
+    </context-param>
+
+    <servlet>
+        <servlet-name>RackServlet</servlet-name>
+        <servlet-class>org.jruby.rack.RackServlet</servlet-class>
+    </servlet>
+
+    <servlet-mapping>
+        <servlet-name>RackServlet</servlet-name>
+        <url-pattern>/*</url-pattern>
+    </servlet-mapping>
+
+    <listener>
+      <listener-class>org.jruby.rack.RackServletContextListener</listener-class>
+    </listener>
+
+</web-app>
+EOF
+  end
+
+  def create_rackup_file(path = 'config')
+    @rackup ||= config_file File.join(path, 'config.ru'), <<-EOF
+require 'rubygems'
+require 'sinatra'
+
+run App
+EOF
+  end
+
   private 
-  def config_file(path, options)
-    File.open(path, 'w') {|io| io.write(options) }
+  def config_file(path, content)
+    File.open(path, 'w') {|io| io.write(content) }
   end
 end

data/spec/trinidad/server_spec.rb

@@ -12,47 +12,50 @@ describe Trinidad::Server do
 
   it "enables catalina naming" do
     Trinidad::Server.new
-    JSystem.getProperty(JContext.URL_PKG_PREFIXES).should  include("org.apache.naming")
-    JSystem.getProperty(JContext.INITIAL_CONTEXT_FACTORY).should == "org.apache.naming.java.javaURLContextFactory"
-    JSystem.getProperty("catalina.useNaming").should == "true"
+    JSystem.get_property(JContext.URL_PKG_PREFIXES).should  include("org.apache.naming")
+    JSystem.get_property(JContext.INITIAL_CONTEXT_FACTORY).should == "org.apache.naming.java.javaURLContextFactory"
+    JSystem.get_property("catalina.useNaming").should == "true"
   end
 
-  it "should have ssl disabled when config param is nil" do
+  it "disables ssl when config param is nil" do
     server = Trinidad::Server.new
     server.ssl_enabled?.should be_false
   end
 
-  it "should have ajp disabled when config param is nil" do
+  it "disables ajp when config param is nil" do
     server = Trinidad::Server.new
     server.ajp_enabled?.should be_false
   end
 
-  it "should have ssl enabled when config param is a number" do
+  it "enables ssl when config param is a number" do
     server = Trinidad::Server.new({:ssl => {:port => 8443},
       :web_app_dir => MOCK_WEB_APP_DIR})
 
     server.ssl_enabled?.should be_true
+    File.exist?('ssl').should be_true
   end
 
-  it "should have ajp enabled when config param is a number" do
+  it "enables ajp when config param is a number" do
     server = Trinidad::Server.new({:ajp => {:port => 8009}})
 
     server.ajp_enabled?.should be_true
   end
 
-  it "should have a connector with https scheme" do
+  it "includes a connector with https scheme when ssl is enabled" do
     server = Trinidad::Server.new({:ssl => {:port => 8443},
       :web_app_dir => MOCK_WEB_APP_DIR})
 
-    server.tomcat.service.findConnectors().should have(1).connectors
-    server.tomcat.service.findConnectors()[0].scheme.should == 'https'
+    connectors = server.tomcat.service.find_connectors
+    connectors.should have(1).connector
+    connectors[0].scheme.should == 'https'
   end
 
-  it "should have an ajp connector enabled" do
+  it "includes a connector with protocol AJP when ajp is enabled" do
     server = Trinidad::Server.new({:ajp => {:port => 8009}})
 
-    server.tomcat.service.findConnectors().should have(1).connectors
-    server.tomcat.service.findConnectors()[0].protocol.should == 'AJP/1.3'
+    connectors = server.tomcat.service.find_connectors
+    connectors.should have(1).connector
+    connectors[0].protocol.should == 'AJP/1.3'
   end
 
   it "loads one application for each option present into :web_apps" do
@@ -71,43 +74,100 @@ describe Trinidad::Server do
       }
     })
 
-    context_loaded = server.tomcat.host.findChildren()
+    context_loaded = server.tomcat.host.find_children
     context_loaded.should have(3).web_apps
 
     expected = ['/mock1', '/mock2', '/']
     context_loaded.each do |context|
-      expected.delete(context.getPath()).should == context.getPath()
+      expected.delete(context.path).should == context.path
     end
   end
 
   it "loads the default application from the current directory if :web_apps is not present" do
     server = Trinidad::Server.new({:web_app_dir => MOCK_WEB_APP_DIR})
 
-    default_context_should_be_loaded(server.tomcat.host.findChildren())
+    default_context_should_be_loaded(server.tomcat.host.find_children)
   end
 
-  it "loads the default application from the current directory using the rackup file if :web_apps is not present" do
+  it "removes default servlets from the application" do
+    server = Trinidad::Server.new({:web_app_dir => MOCK_WEB_APP_DIR})
+    app = server.tomcat.host.find_child('/')
+
+    app.find_child('default').should be_nil
+    app.find_child('jsp').should be_nil
+
+    app.find_servlet_mapping('*.jsp').should be_nil
+    app.find_servlet_mapping('*.jspx').should be_nil
+
+    app.process_tlds.should be_false
+  end
+
+  it "uses the default HttpConnector when http is not configured" do
+    server = Trinidad::Server.new({:web_app_dir => MOCK_WEB_APP_DIR})
+    server.http_configured?.should be_false
+
+    server.tomcat.connector.protocol_handler_class_name.should == 'org.apache.coyote.http11.Http11Protocol'
+  end
+
+  it "uses the NioConnector when the http configuration sets nio to true" do
     server = Trinidad::Server.new({
       :web_app_dir => MOCK_WEB_APP_DIR,
-      :rackup => 'config.ru'
+      :http => {:nio => true}
     })
+    server.http_configured?.should be_true
 
-    context = default_context_should_be_loaded(server.tomcat.host.findChildren())
-    context.findParameter('rackup').gsub(/\s+/, ' ').should == "require 'rubygems' require 'sinatra'"
+    server.tomcat.connector.protocol_handler_class_name.should == 'org.apache.coyote.http11.Http11NioProtocol'
   end
 
-  it "removes default servlets from the application" do
+  it "configures NioConnector with http option values" do
+    server = Trinidad::Server.new({
+      :web_app_dir => MOCK_WEB_APP_DIR,
+      :http => {
+        :nio => true,
+        'maxKeepAliveRequests' => 4,
+        'socket.bufferPool' => 1000
+      }
+    })
+    connector = server.tomcat.connector
+    connector.get_property('maxKeepAliveRequests').should == 4
+    connector.get_property('socket.bufferPool').should == '1000'
+  end
+
+  it "adds the WebAppLifecycleListener to each webapp" do
     server = Trinidad::Server.new({:web_app_dir => MOCK_WEB_APP_DIR})
-    app = server.tomcat.host.find_child('/')
+    app_context = server.tomcat.host.find_child('/')    
 
-    app.find_child('default').should be_nil
-    app.find_child('jsp').should be_nil
+    app_context.find_lifecycle_listeners.map {|l| l.class.name }.should include('Trinidad::WebAppLifecycleListener')
+  end
+
+  it "loads application extensions from the root of the configuration" do
+    server = Trinidad::Server.new({
+      :web_app_dir => MOCK_WEB_APP_DIR,
+      :extensions => { :foo => {} }
+    })
+
+    app_context = server.tomcat.host.find_child('/')
+    app_context.doc_base.should == 'foo_app_extension'
+  end
+
+  it "doesn't create a default keystore when the option SSLCertificateFile is present in the ssl configuration options" do
+    require 'fileutils'
+    FileUtils.rm_rf 'ssl'
+
+    server = Trinidad::Server.new({
+      :ssl => {
+        :port => 8443,
+        :SSLCertificateFile => '/usr/local/ssl/server.crt'
+      },
+      :web_app_dir => MOCK_WEB_APP_DIR})
+
+    File.exist?('ssl').should be_false
   end
 
   def default_context_should_be_loaded(children)
     children.should have(1).web_apps
-    children[0].getDocBase().should == MOCK_WEB_APP_DIR
-    children[0].getPath().should == '/'
+    children[0].doc_base.should == MOCK_WEB_APP_DIR
+    children[0].path.should == '/'
     children[0]
   end
 end

data/spec/trinidad/web_app_lifecycle_listener_spec.rb

@@ -0,0 +1,179 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/fakeapp'
+
+include FakeApp
+
+# adding accessor for tests
+class Trinidad::WebAppLifecycleListener
+  attr_accessor :context
+end
+
+import org.apache.catalina.Lifecycle
+
+describe Trinidad::WebAppLifecycleListener do
+  before do
+    @mock = mock
+    @mock.stubs(:type).returns(Lifecycle::BEFORE_START_EVENT)
+    @mock.stubs(:lifecycle).returns(Trinidad::Tomcat::StandardContext.new)
+
+    @tomcat = Trinidad::Tomcat::Tomcat.new
+    @tomcat.host.app_base = Dir.pwd
+  end
+
+  it "ignores the event when it's not BEFORE_START_EVENT" do
+    listener = Trinidad::WebAppLifecycleListener.new(nil)
+    @mock.stubs(:type).returns(Lifecycle::BEFORE_STOP_EVENT)
+    lambda {
+      listener.lifecycleEvent(@mock)
+    }.should_not raise_error
+  end
+
+  it "tries to initialize the context when the event is BEFORE_START_EVENT" do
+    listener = Trinidad::WebAppLifecycleListener.new(nil)
+    lambda {
+      listener.lifecycleEvent(@mock)
+    }.should raise_error
+  end
+
+  it "doesn't load a default web xml when the deployment descriptor is not provided" do
+    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {}))
+    listener.configure_deployment_descriptor.should be_nil
+  end
+
+  it "loads a default web xml when the deployment descriptor is provided" do
+    FakeFS do
+      create_rails_web_xml
+
+      listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {
+        :web_app_dir => Dir.pwd,
+        :default_web_xml => 'config/web.xml'
+      }))
+      listener.context = Trinidad::Tomcat::StandardContext.new
+
+      expected_xml = File.join(Dir.pwd, 'config/web.xml')
+      listener.configure_deployment_descriptor.should == expected_xml
+      listener.context.default_web_xml.should == expected_xml
+
+      listener.context.find_lifecycle_listeners.
+        map {|l| l.class.name }.should include('Java::OrgApacheCatalinaStartup::ContextConfig')
+    end
+  end
+
+  it "adds the rack servlet and the mapping for /*" do
+    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {}))
+    listener.context = Trinidad::Tomcat::StandardContext.new
+
+    listener.configure_rack_servlet
+
+    servlet = listener.context.find_child('RackServlet')
+    servlet.should_not be_nil
+    servlet.servlet_class.should == 'org.jruby.rack.RackServlet'
+
+    listener.context.find_servlet_mapping('/*').should == 'RackServlet'
+  end
+
+  it "configures the rack context listener from the web app" do
+    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RackupWebApp.new({}, {}))
+    listener.context = Trinidad::Tomcat::StandardContext.new
+    listener.configure_rack_listener
+
+    listener.context.find_application_listeners.should include('org.jruby.rack.RackServletContextListener')
+  end
+
+  it "adds context parameters from the web app" do
+    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {
+      :jruby_min_runtimes => 1
+    }))
+    listener.context = Trinidad::Tomcat::StandardContext.new
+    listener.configure_init_params
+
+    listener.context.find_parameter('jruby.min.runtimes').should == '1'
+  end
+
+  it "ignores parameters already present in the deployment descriptor" do
+    listener = Trinidad::WebAppLifecycleListener.new(Trinidad::RailsWebApp.new({}, {
+      :jruby_max_runtimes => 1,
+      :web_app_dir => MOCK_WEB_APP_DIR,
+      :default_web_xml => 'config/web.xml'
+    }))
+    listener.init_defaults(@tomcat.add_webapp('/', Dir.pwd))
+
+    listener.context.find_parameter('jruby.max.runtimes').should be_nil
+    listener.context.start
+    listener.context.find_parameter('jruby.max.runtimes').should == '8'
+  end
+
+  it "doesn't load classes into a jar when the libs directory is not present" do
+    web_app = Trinidad::RailsWebApp.new({}, {})
+
+    listener = Trinidad::WebAppLifecycleListener.new(web_app)
+    listener.add_application_jars(web_app.class_loader)
+
+    lambda {
+      web_app.class_loader.find_class('org.ho.yaml.Yaml')
+    }.should raise_error
+  end
+
+  it "loads classes into a jar when the libs directory is provided" do
+    web_app = Trinidad::RailsWebApp.new({}, {
+      :web_app_dir => MOCK_WEB_APP_DIR,
+      :libs_dir => 'lib'
+    })
+
+    listener = Trinidad::WebAppLifecycleListener.new(web_app)
+    listener.add_application_jars(web_app.class_loader)
+
+    lambda {
+      web_app.class_loader.find_class('org.ho.yaml.Yaml').should_not be_nil
+    }.should_not raise_error
+  end
+
+  it "doesn't load java classes when the classes directory is not present" do
+    web_app = Trinidad::RailsWebApp.new({}, {})
+
+    listener = Trinidad::WebAppLifecycleListener.new(web_app)
+    listener.add_application_java_classes(web_app.class_loader)
+
+    lambda {
+      web_app.class_loader.find_class('HelloTomcat')
+    }.should raise_error
+  end
+
+  it "loads java classes when the classes directory is provided" do
+    web_app = Trinidad::RailsWebApp.new({}, {
+      :web_app_dir => MOCK_WEB_APP_DIR,
+      :classes_dir => 'classes'
+    })
+
+    listener = Trinidad::WebAppLifecycleListener.new(web_app)
+    listener.add_application_java_classes(web_app.class_loader)
+
+    lambda {
+      web_app.class_loader.find_class('HelloTomcat').should_not be_nil
+    }.should_not raise_error
+  end
+
+  it "creates a WebappLoader with the JRuby class loader" do
+    web_app = Trinidad::RailsWebApp.new({}, {})
+
+    listener = Trinidad::WebAppLifecycleListener.new(web_app)
+    listener.context = Trinidad::Tomcat::StandardContext.new
+    listener.configure_context_loader
+
+    loader = listener.context.loader
+
+    loader.should be_instance_of(Java::OrgApacheCatalinaLoader::WebappLoader)
+  end
+
+  it "loads the default application from the current directory using the rackup file if :web_apps is not present" do
+    web_app = Trinidad::RackupWebApp.new({
+      :web_app_dir => MOCK_WEB_APP_DIR,
+      :rackup => 'config.ru'
+    }, {})
+    listener = Trinidad::WebAppLifecycleListener.new(web_app)
+    listener.context = Trinidad::Tomcat::StandardContext.new
+    listener.configure_init_params
+
+    listener.context.find_parameter('rackup.path').should == "config.ru"
+  end
+end

data/spec/trinidad/web_app_spec.rb

@@ -1,144 +1,175 @@
 require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/fakeapp'
 
-describe Trinidad::WebApp do
-  before do
-    @tomcat = Trinidad::Tomcat::Tomcat.new
-    @tomcat.host.app_base = Dir.pwd
-    @tomcat_web_app = @tomcat.addWebapp('/', File.dirname(__FILE__) + '/../../')
-
-    @app = {
-      :web_app_dir => MOCK_WEB_APP_DIR,
-      :context_path => '/'
-    }
-    @config = {
-      :libs_dir => 'lib',
-      :classes_dir => 'classes',
-      :default_web_xml => 'config/web.xml',
-      :jruby_min_runtimes => 2,
-      :jruby_max_runtimes => 6,
-      :web_apps => {
-        :default => @app
-      }
-    }
-    @web_app = Trinidad::RailsWebApp.new(@tomcat_web_app, @config, @app)
-  end
+include FakeApp
 
+describe Trinidad::WebApp do
   it "creates a RailsWebApp if rackup option is not present" do
-    app = Trinidad::WebApp.create(@tomcat_web_app, @config, @app)
+    app = Trinidad::WebApp.create({}, {})
     app.should be_an_instance_of(Trinidad::RailsWebApp)
   end
 
   it "creates a RackupWebApp if rackup option is present" do
-    rackup_app = {:rackup => 'config.ru'}
-    @config.deep_merge({:web_apps => {:default => rackup_app}})
-    app = Trinidad::WebApp.create(@tomcat_web_app, @config, rackup_app)
+    app = Trinidad::WebApp.create({}, {:rackup => 'config.ru'})
     app.should be_an_instance_of(Trinidad::RackupWebApp)
   end
 
-  it "should load custom jars" do 
-    class_loader = org.jruby.util.JRubyClassLoader.new(JRuby.runtime.jruby_class_loader)
-    @web_app.add_application_libs(class_loader)
+  it "ignores rack_servlet when a deployment descriptor already provides it" do
+    FakeFS do
+      create_rails_web_xml
 
-    resource = class_loader.find_class('org.ho.yaml.Yaml')
-    resource.should_not be_nil
+      app = Trinidad::WebApp.create({}, {
+        :web_app_dir => Dir.pwd,
+        :default_web_xml => 'config/web.xml'
+      })
+      app.servlet.should be_nil
+    end
   end
 
-  it "should load custom classes" do
-    class_loader = org.jruby.util.JRubyClassLoader.new(JRuby.runtime.jruby_class_loader)
-    @web_app.add_application_classes(class_loader)
+  it "ignores rack_listener when a deployment descriptor already provides it" do
+    FakeFS do
+      create_rails_web_xml
 
-    resource = class_loader.find_class('HelloTomcat')
-    resource.should_not be_nil
+      app = Trinidad::WebApp.create({}, {
+        :web_app_dir => Dir.pwd,
+        :default_web_xml => 'config/web.xml'
+      })
+      app.rack_listener.should be_nil
+    end
   end
 
-  it "should start application context without errors" do
-    start_context
+  it "uses rack_servlet as the default servlet when a deployment descriptor is not provided" do
+    app = Trinidad::WebApp.create({}, {})
+    app.servlet.should_not be_nil
+    app.servlet[:name].should == 'RackServlet'
+    app.servlet[:class].should == 'org.jruby.rack.RackServlet'
   end
 
-  it "should add a filter from the default web.xml" do
-    start_context_with_web_xml
-    @web_app.context.findFilterDefs().should have(1).filters
+  it "uses rack_listener as the default listener when a deployment descriptor is not provided" do
+    app = Trinidad::WebApp.create({}, {})
+    app.rack_listener.should == 'org.jruby.rack.rails.RailsServletContextListener'
   end
 
-  it "shouldn't duplicate init params" do
-    start_context_with_web_xml
-    lambda { @web_app.add_init_params }.should_not raise_error
+  it "loads the context parameters from the configuration when a deployment descriptor is not provided" do
+    app = Trinidad::WebApp.create({}, {
+      :jruby_min_runtimes => 1,
+      :jruby_max_runtimes => 1,
+      :public => 'foo',
+      :environment => :production
+    })
+    parameters = app.init_params
+    parameters['jruby.min.runtimes'].should == '1'
+    parameters['jruby.initial.runtimes'].should == '1'
+    parameters['jruby.max.runtimes'].should == '1'
+    parameters['public.root'].should == '/foo'
+    parameters['rails.env'].should == 'production'
+    parameters['rails.root'].should == '/'
   end
 
-  it "loads init params from configuration root" do
-    @web_app.add_init_params
+  it "adds the rackup script as a context parameter when it's provided" do
+    FakeFS do
+      create_rackup_file
+      app = Trinidad::WebApp.create({}, {
+        :web_app_dir => Dir.pwd,
+        :rackup => 'config/config.ru'
+      })
 
-    @web_app.context.findParameter('jruby.min.runtimes').should == '2'
-    @web_app.context.findParameter('jruby.max.runtimes').should == '6'
+      parameters = app.init_params
+      parameters['rackup.path'].should == 'config/config.ru'
+    end
   end
 
-  it 'loads init params from application node' do
-    @app[:jruby_min_runtimes] = 4
-    @app[:jruby_max_runtimes] = 8
-    @config[:web_apps][:default] = @app
+  it "ignores parameters from configuration when the deployment descriptor already contains them" do
+    FakeFS do
+      create_rackup_web_xml
 
-    web_app = Trinidad::WebApp.create(@tomcat_web_app, @config, @app)
-    web_app.add_init_params
+      app = Trinidad::WebApp.create({}, {
+        :web_app_dir => Dir.pwd,
+        :default_web_xml => 'config/web.xml',
+        :jruby_min_runtimes => 2,
+        :jruby_max_runtimes => 5
+      })
+      parameters = app.init_params
 
-    web_app.context.findParameter('jruby.min.runtimes').should == '4'
-    web_app.context.findParameter('jruby.max.runtimes').should == '8'
+      parameters['jruby.min.runtimes'].should be_nil
+      parameters['jruby.max.runtimes'].should be_nil
+    end
   end
 
-  it "configures rack handler" do
-    @web_app.configure_rack
-    @web_app.context.findChild('RackServlet').should_not be_nil
+  it "ignores the deployment descriptor when it doesn't exist" do
+    app = Trinidad::WebApp.create({}, {
+      :web_app_dir => Dir.pwd,
+      :default_web_xml => 'config/web.xml'
+    })
+    app.default_deployment_descriptor.should be_nil
   end
 
-  it "configures rack listener" do
-    @web_app.add_rack_context_listener
-    @web_app.context.findApplicationListeners().should have(1).listeners
+  it "doesn't load any web.xml when the deployment descriptor doesn't exist" do
+    app = Trinidad::WebApp.create({}, {
+      :web_app_dir => Dir.pwd,
+      :default_web_xml => 'config/web.xml'
+    })
+    app.rack_servlet_configured?.should be_false
+    app.rack_listener_configured?.should be_false
   end
 
-  it "has rack handler already configured when web.xml includes it" do
-    @web_app.load_default_web_xml
-    @web_app.rack_configured?().should  be_true
-
-    @web_app.configure_rack
-    @web_app.context.findChild('RackServlet').should be_nil
+  it "uses `public` as default public root directory" do
+    app = Trinidad::WebApp.create({}, {})
+    app.public_root.should == 'public'
   end
 
-  it "has rack listener already configured when web.xml includes it" do
-    @web_app.load_default_web_xml
-    @web_app.rack_listener_configured?().should be_true
-
-    @web_app.add_rack_context_listener
-    @web_app.context.findApplicationListeners().should have(0).listeners
+  it "uses extensions from the global configuration" do
+    config = { :extensions => {:hotdeploy => {}} }
+    app = Trinidad::WebApp.create(config, {})
+    app.extensions.should include(:hotdeploy)
   end
 
-  it "loads the provided web.xml for rails applications" do
-    @config[:default_web_xml] = 'config/foo.xml'
-    app = Trinidad::WebApp.create(@tomcat_web_app, @config, @app)
-
-    app.load_default_web_xml
-    app.context.default_web_xml.should =~ /rails_web.xml$/
+  it "overrides global extensions with application extensions" do
+    config = { :extensions => {:hotdeploy => {}} }
+    app_config = { :extensions => {:hotdeploy => {:delay => 30000}} }
+    app = Trinidad::WebApp.create(config, app_config)
+    app.extensions[:hotdeploy].should include(:delay)
   end
 
-  it "loads the provided web.xml for rack applications" do
-    @config[:default_web_xml] = 'config/foo.xml'
-    @app[:rackup] = 'config.ru'
+  it "creates a rackup application when the rackup file is under WEB-INF directory" do
+    FakeFS do
+      create_rackup_file('WEB-INF')
+      app = Trinidad::WebApp.create({}, {})
+
+      app.should be_an_instance_of(Trinidad::RackupWebApp)
+    end
+  end
 
-    app = Trinidad::WebApp.create(@tomcat_web_app, @config, @app)
-    app.load_default_web_xml
-    app.context.default_web_xml.should =~ /rackup_web.xml$/
-  end
+  it "doesn't add the rackup init parameter when the rackup file is under WEB-INF directory" do
+    FakeFS do
+      create_rackup_file('WEB-INF')
+      app = Trinidad::WebApp.create({}, {})
 
-  def start_context_with_web_xml
-    @web_app.load_default_web_xml
-    start_context
+      app.init_params.should_not include('rackup.path')
+    end
   end
 
-  def start_context
-    load_tomcat_libs
-    lambda { @web_app.context.start }.should_not raise_error
+  it "loads rackup file from a given directory" do
+    FakeFS do
+      create_rackup_file('rack')
+      app = Trinidad::WebApp.create({}, {
+        :web_app_dir => Dir.pwd,
+        :rackup => 'rack'
+      })
+      app.init_params.should include('rackup.path')
+      app.init_params['rackup.path'].should == 'rack/config.ru'
+    end
   end
 
-  def load_tomcat_libs
-    @web_app.config[:libs_dir] = File.join(File.dirname(__FILE__), '..', '..', 'tomcat-libs')
-    @web_app.add_context_loader
+  it "allows to configure the servlet from the configuration options" do
+    app = Trinidad::WebApp.create({}, {
+      :servlet => {
+        :class => 'org.jruby.trinidad.FakeServlet',
+        :name => 'FakeServlet'
+      }
+    })
+
+    app.servlet[:class].should == 'org.jruby.trinidad.FakeServlet'
+    app.servlet[:name].should == 'FakeServlet'
   end
 end

metadata

@@ -1,12 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: trinidad_jars
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  hash: 31098201
+  prerelease: true
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  - beta
+  version: 0.3.0.beta
 platform: ruby
 authors: 
 - David Calavera
@@ -14,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-28 00:00:00 +02:00
+date: 2010-07-01 00:00:00 +02:00
 default_executable: trinidad
 dependencies: []
 
@@ -32,6 +34,16 @@ files:
 - trinidad-libs/tomcat-core.jar
 - LICENSE
 - README.rdoc
+- spec/fixtures/trinidad_foo_extension.rb
+- spec/fixtures/trinidad_override_tomcat_extension.rb
+- spec/spec_helper.rb
+- spec/trinidad/command_line_parser_spec.rb
+- spec/trinidad/extensions_spec.rb
+- spec/trinidad/fakeapp.rb
+- spec/trinidad/server_spec.rb
+- spec/trinidad/web_app_lifecycle_listener_spec.rb
+- spec/trinidad/web_app_spec.rb
+- bin/trinidad
 has_rdoc: true
 homepage: http://calavera.github.com/trinidad
 licenses: []
@@ -42,23 +54,29 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: trinidad_jars
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Common jars for Trinidad
@@ -70,4 +88,5 @@ test_files:
 - spec/trinidad/extensions_spec.rb
 - spec/trinidad/fakeapp.rb
 - spec/trinidad/server_spec.rb
+- spec/trinidad/web_app_lifecycle_listener_spec.rb
 - spec/trinidad/web_app_spec.rb