halcyon 0.4.0 → 0.5.0

data/spec/halcyon/client_spec.rb

@@ -0,0 +1,63 @@
+#--
+# Start App for Tests
+# and wait for it to be responsive
+#++
+
+fork do
+  dir = Halcyon.root/'support'/'generators'/'halcyon'/'templates'
+  command = "thin start -R runner.ru -p 89981 -c #{dir} > /dev/null 2>&1"
+  STDOUT.close
+  STDERR.close
+  exec command
+end
+client = Halcyon::Client.new('http://localhost:89981')
+begin
+  sleep 1.5
+  client.get('/time')
+rescue Errno::ECONNREFUSED => e
+  retry
+end
+
+#--
+# Cleanup
+#++
+
+at_exit do
+  pids = (`ps auxww | grep support/generators/halcyon/templates`).split("\n").collect{|pid|pid.match(/(\w+)\s+(\w+).+/)[2]}
+  pids.each {|pid| Process.kill(9, pid.to_i) rescue nil }
+end
+
+#--
+# Tests
+#++
+
+describe "Halcyon::Client" do
+  
+  before do
+    @client = Halcyon::Client.new('http://localhost:89981')
+  end
+  
+  it "should perform requests and return the response values" do
+    response = @client.get('/time')[:body]
+    response.length.should > 25
+    response.include?(Time.now.year.to_s).should.be.true?
+  end
+  
+  it "should be able to perform get, post, put, and delete requests" do
+    @client.get('/time')[:body].length.should > 25
+    @client.post('/time')[:body].length.should > 20
+    @client.put('/time')[:body].should == "Not Implemented"
+    @client.delete('/time')[:status].should == 501
+  end
+  
+  it "should throw exceptions unless an OK response is sent if toggled to" do
+    # default behavior is to not raise exceptions
+    @client.get('/nonexistent/route')[:status].should == 404
+    
+    # tell it to raise exceptions
+    @client.raise_exceptions! true
+    should.raise(Halcyon::Exceptions::NotFound) { @client.get('/nonexistent/route') }
+    @client.get('/time')[:status].should == 200
+  end
+  
+end

data/spec/halcyon/controller_spec.rb

@@ -0,0 +1,68 @@
+describe "Halcyon::Controller" do
+  
+  before do
+    @log = ''
+    @logger = Logger.new(StringIO.new(@log))
+    @config = $config.dup
+    @config[:logger] = @logger
+    @config[:app] = 'Specs'
+    Halcyon.config = @config
+    @app = Halcyon::Runner.new
+  end
+  
+  it "should provide various shorthand methods for simple responses but take custom response values" do
+    controller = Specs.new(Rack::MockRequest.env_for('/'))
+    
+    response = {:status => 200, :body => 'OK'}
+    controller.ok.should == response
+    controller.success.should == response
+    
+    controller.ok('').should == {:status => 200, :body => ''}
+    controller.ok(['OK', 'Sure Thang', 'Correcto']).should == {:status => 200, :body => ['OK', 'Sure Thang', 'Correcto']}
+  end
+  
+  it "should provide a quick way to find out what method the request was performed using" do
+    %w(GET POST PUT DELETE).each do |m|
+      controller = Specs.new(Rack::MockRequest.env_for('/', :method => m))
+      controller.method.should == m.downcase.to_sym
+    end
+  end
+  
+  it "should provide convenient access to GET and POST data" do
+    controller = Specs.new(Rack::MockRequest.env_for("/#{rand}?foo=bar"))
+    controller.get[:foo].should == 'bar'
+    
+    controller = Specs.new(Rack::MockRequest.env_for("/#{rand}", :method => 'POST', :input => {:foo => 'bar'}.to_params))
+    controller.post[:foo].should == 'bar'
+  end
+  
+  it "should parse URI query params correctly" do
+    controller = Specs.new(Rack::MockRequest.env_for("/?query=value&lang=en-US"))
+    controller.get[:query].should == 'value'
+    controller.get[:lang].should == 'en-US'
+  end
+  
+  it "should parse the URI correctly" do
+    controller = Specs.new(Rack::MockRequest.env_for("http://localhost:4000/slaughterhouse/5"))
+    controller.uri.should == '/slaughterhouse/5'
+    
+    controller = Specs.new(Rack::MockRequest.env_for("/slaughterhouse/5"))
+    controller.uri.should == '/slaughterhouse/5'
+    
+    controller = Specs.new(Rack::MockRequest.env_for(""))
+    controller.uri.should == '/'
+  end
+
+  it 'should provide url accessor for resource index route' do
+    controller = Resources.new(Rack::MockRequest.env_for("/resources"))
+    controller.uri.should == controller.url(:resources)
+  end
+
+  it 'should provide url accessor for resource show route' do
+    resource = Model.new
+    resource.id = 1
+    controller = Resources.new(Rack::MockRequest.env_for("/resources/1"))
+    controller.uri.should == controller.url(:resource, resource)
+  end
+  
+end

data/spec/halcyon/halcyon_spec.rb

@@ -0,0 +1,63 @@
+describe "Halcyon" do
+  
+  before do
+    @log = ''
+    @logger = Logger.new(StringIO.new(@log))
+    @config = $config.dup
+    @config[:logger] = @logger
+    @config[:app] = 'Specs'
+    Halcyon.config = @config
+    @app = Halcyon::Runner.new
+  end
+  
+  it "should provide the path of the application root directory" do
+    Halcyon.root.should == Dir.pwd
+  end
+  
+  it "should provide quick access to the configuration hash" do
+    Halcyon.config.is_a?(Hash).should.be.true?
+  end
+  
+  it "should provide environment label" do
+    Halcyon.environment.should == :development
+    Halcyon.environment.should == Halcyon.config[:environment]
+  end
+  
+  it "should provide universal access to a logger" do
+    # We assume Logger here because, you know, we're gods of the test
+    Halcyon.logger.is_a?(Logger).should.be.true?
+    # And this is just a side affect of making the logger universally accessible
+    {}.logger.is_a?(Logger).should.be.true?
+  end
+  
+  it "should provide the (estimated) application name" do
+    # We set this above
+    Halcyon.app.should == "Specs"
+  end
+  
+  it "should provide sane default paths for essential components" do
+    Halcyon.paths.is_a?(Hash).should.be.true?
+    Halcyon.paths[:controller].should == Halcyon.root/"app"
+    Halcyon.paths[:lib].should == Halcyon.root/"lib"
+    Halcyon.paths[:config].should == Halcyon.root/"config"
+    Halcyon.paths[:init].should == Halcyon.root/"config"/"{init,initialize}"
+    Halcyon.paths[:log].should == Halcyon.root/"log"
+  end
+  
+  it "should provide configurable attribute definition for quick access to specific configuration values" do
+    test_method = "oracle"
+    method_count = Halcyon.methods.length
+    Halcyon.configurable("oracle")
+    (Halcyon.methods.length - method_count).should == 2
+    Halcyon.method(test_method.to_sym).is_a?(Method).should.be.true?
+    Halcyon.method("#{test_method}=".to_sym).is_a?(Method).should.be.true?
+    Halcyon.send("#{test_method}=".to_sym, 10)
+    Halcyon.send(test_method).should == Halcyon.config[test_method.to_sym]
+  end
+  
+  it "should predefine quick access to the 'db' configuration value" do
+    Halcyon.db = 100
+    Halcyon.db.should == Halcyon.config[:db]
+  end
+  
+end

data/spec/halcyon/logging_spec.rb

@@ -0,0 +1,31 @@
+describe "Halcyon::Logging" do
+  
+  it "should set the default logger when none specified" do
+    Halcyon.send(:remove_const, :Logger)
+    Halcyon::Logging.set
+    Halcyon::Logger.ancestors.include?(::Logger).should.be.true?
+  end
+  
+  it "should set the logger type specified" do
+    Halcyon.send(:remove_const, :Logger)
+    Halcyon::Logging.set('Logger')
+    Halcyon::Logger.ancestors.include?(::Logger).should.be.true?
+    
+    # Not running these because the above test is equivalent as well as
+    # throwing errors for folks who do not have Logging, Log4r, and
+    # Analogger installed.
+    
+    # Halcyon.send(:remove_const, :Logger)
+    # Halcyon::Logging.set('Analogger')
+    # Halcyon::Logger.ancestors.include?(::Swiftcore::Analogger::Client).should.be.true?
+    # 
+    # Halcyon.send(:remove_const, :Logger)
+    # Halcyon::Logging.set('Log4r')
+    # Halcyon::Logger.ancestors.include?(::Log4r::Logger).should.be.true?
+    # 
+    # Halcyon.send(:remove_const, :Logger)
+    # Halcyon::Logging.set('Logging')
+    # Halcyon::Logger.ancestors.include?(::Logging::Logger).should.be.true?
+  end
+  
+end

data/spec/halcyon/router_spec.rb

@@ -1,32 +1,57 @@
-describe "Halcyon::Server::Router" do
+describe "Halcyon::Application::Router" do
   
   before do
-    @app = Specr.new :port => 4000
+    @log = ''
+    @logger = Logger.new(StringIO.new(@log))
+    @config = $config.dup
+    @config[:logger] = @logger
+    Halcyon.config = @config
+    @app = Halcyon::Runner.new
   end
   
-  it "should prepares routes correctly when written correctly" do
+  it "should prepare routes correctly when written correctly" do
     # routes have been defined for Specr
-    Halcyon::Server::Router.routes.should.not == []
-    Halcyon::Server::Router.routes.length.should > 0
+    Halcyon::Application::Router.routes.should.not == []
+    Halcyon::Application::Router.routes.length.should > 0
   end
   
   it "should match URIs to the correct route" do
-    Halcyon::Server::Router.route(Rack::MockRequest.env_for('/'))[:action].should == 'index'
+    request = Rack::Request.new(Rack::MockRequest.env_for('/'))
+    Halcyon::Application::Router.route(request)[:action].should == 'index'
   end
   
   it "should use the default route if no matching route is found" do
-    Halcyon::Server::Router.route(Rack::MockRequest.env_for('/erroneous/path'))[:action].should == 'not_found'
-    Halcyon::Server::Router.route(Rack::MockRequest.env_for("/random/#{rand}"))[:action].should == 'not_found'
+    # missing instead of not_found because we gave a different default route 
+    request = Rack::Request.new(Rack::MockRequest.env_for("/erroneous/path/#{rand}/#{rand}"))
+    Halcyon::Application::Router.route(request)[:action].should == 'missing'
+    
+    request = Rack::Request.new(Rack::MockRequest.env_for("/random/#{rand}/#{rand}"))
+    Halcyon::Application::Router.route(request)[:action].should == 'missing'
   end
   
   it "should map params in routes to parameters" do
-     response = Halcyon::Server::Router.route(Rack::MockRequest.env_for('/hello/Matt'))
-     response[:action].should == 'greeter'
-     response[:name].should == 'Matt'
+    request = Rack::Request.new(Rack::MockRequest.env_for('/hello/Matt'))
+    response = Halcyon::Application::Router.route(request)
+    response[:action].should == 'greeter'
+    response[:name].should == 'Matt'
   end
   
   it "should supply arbitrary routing param values included as a param even if not in the URI" do
-    Halcyon::Server::Router.route(Rack::MockRequest.env_for('/'))[:arbitrary].should == 'random'
+    request = Rack::Request.new(Rack::MockRequest.env_for('/'))
+    request.env['rack.input'] << "arbitrary=random"
+    Halcyon::Application::Router.route(request)[:arbitrary].should == 'random'
+  end
+  
+  it "should match index method of resources" do
+    index_req = Rack::Request.new(Rack::MockRequest.env_for('/resources'))
+    Halcyon::Application::Router.route(index_req)[:controller].should == 'resources'
+    Halcyon::Application::Router.route(index_req)[:action].should == 'index'
+  end
+
+  it "should match show method of resource" do
+    show_req = Rack::Request.new(Rack::MockRequest.env_for('/resources/id'))
+    Halcyon::Application::Router.route(show_req)[:controller].should == 'resources'
+    Halcyon::Application::Router.route(show_req)[:action].should == 'show'
   end
   
 end

data/spec/halcyon/runner_spec.rb

@@ -0,0 +1,54 @@
+module Kernel
+  alias_method :__warn, :warn
+  def warn(msg)
+    $warning = msg
+    __warn(msg) if $do_warns
+  end
+end
+
+describe "Halcyon::Runner" do
+  
+  before do
+    @log = ''
+    @logger = Logger.new(StringIO.new(@log))
+    @config = $config.dup
+    @config[:logger] = @logger
+    Halcyon.config = @config
+    @app = Halcyon::Runner.new
+  end
+  
+  it "should warn if a non-existent config file is loaded" do
+    $do_warns = false
+    path = Halcyon.root/'config'/'config.yml'
+    Halcyon::Runner.load_config(path).nil?.should == true
+    $warning.should =~ %r{#{path} not found}
+    $do_warns = true
+  end
+  
+  it "should set up logging according to configuration" do
+    time = Time.now.to_s
+    @app.logger.debug "Test message for #{time}"
+    @log.should =~ /Test message for #{time}/
+  end
+  
+  it "should recognize what application it is running as" do
+    # Without setting explicitly in config
+    Halcyon.app.should == Halcyon.root.split('/').last.camel_case
+    
+    # With setting explicitly in config
+    Halcyon.config[:app] = 'Specr'
+    Halcyon::Runner.new
+    Halcyon.app.should == 'Specr'
+    
+    # Setting directly
+    Halcyon.app = 'Specr2'
+    Halcyon.app.should == 'Specr2'
+  end
+  
+  it "should proxy calls to Halcyon::Application" do
+    status, headers, body = @app.call(Rack::MockRequest.env_for('/'))
+    status.should == 200
+    body.body[0].should == Specs.new(Rack::MockRequest.env_for('/')).send(:index).to_json
+  end
+  
+end

data/spec/spec_helper.rb

@@ -1,21 +1,87 @@
-require 'halcyon/server'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'halcyon')
 require 'rack/mock'
+require 'logger'
 
-$test = true
+# Default Settings
 
-class Specr < Halcyon::Server::Base
+$config = {
+  :allow_from => :all,
+  :environment => :development,
+  :logger => nil,
+  :logging => {
+    :level => 'debug'
+  }
+}
+
+# Testing Application
+
+# Default controller
+class Application < Halcyon::Controller; end
+
+# Weird edge-case controller
+class Specs < Application
   
-  route do |r|
-    r.match('/hello/:name').to(:action => 'greeter')
-    r.match('/').to(:action => 'index', :arbitrary => 'random')
+  def greeter
+    ok("Hello #{params[:name]}")
   end
   
-  def index(params)
+  def index
     ok('Found')
   end
   
-  def greeter(params)
-    ok("Hello #{params[:name]}")
+  def cause_exception
+    raise Exception.new("Oops!")
+  end
+  
+  def call_nonexistent_method
+    hash = Hash.new
+    hash.please_dont_exist_and_please_throw_no_method_error
+    ok
   end
   
+  private
+  
+  def undispatchable_private_method
+    "it's private, so it won't be found by the dispatcher"
+  end
+  
+end
+
+# Resources controller
+class Resources < Application
+
+  def index
+    ok('List of resources')
+  end
+
+  def show
+    ok("One resource: #{params[:id]}")
+  end
+end
+
+# Models
+
+class Model
+  attr_accessor :id
+end
+
+# Environment
+
+Halcyon.configurable_attr(:environment)
+
+# Testing routes
+
+Halcyon::Application.route do |r|
+  r.resources :resources
+  
+  r.match('/hello/:name').to(:controller => 'specs', :action => 'greeter')
+  r.match('/:action').to(:controller => 'specs')
+  r.match('/:controller/:action').to()
+  r.match('/').to(:controller => 'specs', :action => 'index', :arbitrary => 'random')
+  # r.default_routes
+  {:action => 'missing'}
+end
+
+Halcyon::Application.startup do |config|
+  $started = true
 end