nephos-server 0.5.4 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e8ff75ee49a1ab28b80920721ad356542a82547
-  data.tar.gz: 54a400165ee4401da84a727cf8e95ed2992d3a6a
+  metadata.gz: deb3406763cd858becf11305040bd3916c3151ef
+  data.tar.gz: 840624b4879a929ce7b1555d598b7555b28f1f50
 SHA512:
-  metadata.gz: 0660a8e017d4824933c80dee460daa445f16a544a7fca14372849a867561e8b028650fd8dc7fe0988434e1d031e018f92699a2f89572a079ecfc646daad1d3e9
-  data.tar.gz: f17a9dafdc7d4d1bb976c099f078c1439a5037c0586fd2abf9a800c97c91ec0744c293b528e240c16b32f6372ddab435d74259a0b22528c4bf3e9b5b38aa9b75
+  metadata.gz: 2ce1336de3d50ec9e9dc42b1c3dab71f071f61c87158770191a62b42642220156aa729446b739f2438e0f758dadc28781934e94ddf4dbd41eb0465d89ea6d865
+  data.tar.gz: a6c4b3d0cd26ed3d4c7f20d8ee81e4dee557df41d31b952225b9417cebcc075fc6b623f59c5b78351672fee16aad8c442918fb67064be51807826e94efdb98e0

data/CHANGELOG

@@ -1,24 +1,29 @@
-v0.5.4
+v0.6.1
+	* Improve daemons
+	* Improve Rakefile and tests structure
+	* Add few functional (router, server, generator) tests
+	* Add new unitary tests
+
+v0.6.0
+	* Big change (ea49dfb0b429f03327447477bfee9bef30dda7ad) on the architecture, massive usage of Rack::Request, review the global architecture, update all unitary tests
+	* add hook before_action and after_action
+	* improve params
+	* improve controller error handlement with STDERR message
+	* server can be daemonized
+
+v0.5
 	* fix regression on empty response
 	* add unitary tests
 	* improve gemspec
 	* fix severe regression on responder
 	* fix environment bug
-
-v0.5.3
 	* add continuous integration with gitlab
 	* fix executables requirements to be testable
 	* add cookies management
-
-v0.5.2
 	* fix regression on content-type from v0.4
-
-v0.5.1
 	* fix nephos gem (binaries can be used out of an application)
 	* improve code documentation (annotations above the methods and classes)
 	* fix content type for json to application/json
-
-v0.5.0
 	* improve executables: version taking in count
 
 v0.4

data/README.md

@@ -1,16 +1,6 @@
 # Nephos Ruby Server
-
-[![Gitlab Tests](https://gitlab.com/ci/projects/8973/status.png?ref=master)](https://gitlab.com/ci/projects/8973?ref=master)
-
-[![GitHub version](https://badge.fury.io/gh/pouleta%2FNephosRubyServer.svg)](http://badge.fury.io/gh/pouleta%2FNephosRubyServer)
-
 [![Gem Version](https://badge.fury.io/rb/nephos-server.svg)](http://badge.fury.io/rb/nephos-server)
 
-[![Code Climate](https://codeclimate.com/github/pouleta/NephosRubyServer/badges/gpa.svg)](https://codeclimate.com/github/pouleta/NephosRubyServer)
-
-[![Nephos Executables](https://badge.fury.io/rb/nephos.svg)](http://badge.fury.io/rb/nephos)
-
-
 This is a minimal web server, based on [rack](https://github.com/rack/rack) and [puma](https://github.com/puma/puma).
 It is written in ruby. It also gives you a minimal architecture
 to speed up your application bootstrap.
@@ -42,6 +32,8 @@ nserver -p 8080 -h 0.0.0.0 # start the server. port is not required, neither hos
 - ``-p``: port to listen
 - ``-h``: host to listen (network address)
 - ``-e``: environment (default is development, can be set to production)
+- ``-d``: daemonize the process
+- ``-k``: kill daemonized process
 
 
 # Documentation
@@ -121,7 +113,6 @@ end
 
 ## TODO v0.6
 - startable as daemon
-- hooks for controller
 - feature to change HTTP header from controller
 - customisable default 404 errors and 500 errors
 - functionnal tests
@@ -136,3 +127,11 @@ end
   - Api Creation
   - Database creation
   - Web HTML with templating
+
+[![Gitlab Tests](https://gitlab.com/ci/projects/8973/status.png?ref=master)](https://gitlab.com/ci/projects/8973?ref=master)
+
+[![GitHub version](https://badge.fury.io/gh/pouleta%2FNephosRubyServer.svg)](http://badge.fury.io/gh/pouleta%2FNephosRubyServer)
+
+[![Code Climate](https://codeclimate.com/github/pouleta/NephosRubyServer/badges/gpa.svg)](https://codeclimate.com/github/pouleta/NephosRubyServer)
+
+[![Nephos Executables](https://badge.fury.io/rb/nephos.svg)](http://badge.fury.io/rb/nephos)

data/Rakefile

@@ -5,3 +5,16 @@ task :default => [:test]
 task :test do
   ruby "test/test.rb"
 end
+
+namespace :test do
+
+  desc "Unitary tests. Fasts and on the sources."
+  task :test do
+    ruby "test/test.rb"
+  end
+
+  desc "Functional tests. Slow, test real the features under real conditions of usage."
+  task :functional do
+    ruby "test/functional.rb"
+  end
+end

data/app/main.rb

@@ -1,9 +1,26 @@
 class MainController < Nephos::Controller
 
+  before_action :fct_before_all
+  before_action :fct_before_root, :root
+  after_action :fct_after_root, :root
+
+  def fct_before_all
+    # puts "BEFORE ALL"
+  end
+
+  def fct_before_root
+    # puts "BEFORE"
+  end
+
+  def fct_after_root
+    # puts "AFTER"
+  end
+
   def root
+    # puts "ROOT"
     cookies["a"] = "b"
     cookies.delete("b").to_h
-    puts cookies
+    # puts "Cookies from the root:", cookies
     {
       json: {
         list: $dataset,
@@ -39,7 +56,7 @@ class MainController < Nephos::Controller
 
   AUTH_IMG_EXT = %w(.jpg .jpeg .png .gif)
   def image
-    dir = File.expand_path('controllers/')
+    dir = File.expand_path('app/')
     file = File.expand_path(params["image"], dir)
     if not file[0..(dir.size-1)] == dir or not AUTH_IMG_EXT.include?(File.extname(file))
       return {status: 500, content: "invalid path #{params['image']}"}

data/bin/nephos-server

@@ -35,12 +35,30 @@ begin
       $test = true
     end
 
+    opts.on("-d", "--daemon", "Start in background") do
+      $daemon = true
+    end
+
+    opts.on("-k", "--kill", "Kill the daemon if started") do
+      $kill_daemon = true
+    end
+
   end.parse!
 
   Nephos.env = $server_env
 
   Dir.chdir(opts[0]) if not opts.empty?
 
+  if $kill_daemon
+    raise "No Daemon started" if not Nephos::Bin::Daemon.started?
+    puts "Daemon #{Nephos::Bin::Daemon.get_pid} stopped"
+    Nephos::Bin::Daemon.kill!
+    exit 0
+  end
+  if $daemon and Nephos::Bin::Daemon.started?
+    raise "Unable to start the server: the daemon #{Nephos::Bin::Daemon.get_pid} already exists"
+  end
+
   if $test
     require_relative "../lib/nephos-server"
   else
@@ -54,12 +72,19 @@ begin
   end
 
   puts "Running Nephos::Server version #{Nephos::VERSION} (#{Nephos.env})"
+  if $daemon
+    Nephos::Bin::Daemon.detach!
+  end
   Nephos::Server.start($server_port, $server_host)
 
 rescue RoutingError => err
   puts "Routing Error: Check out the documentation and `routes.rb` file.".yellow
   puts "#{err.class}: #{err.message}".red
+  puts "#{err.backtrace.join("\n")}".yellow if $debug
+  exit 1
 
 rescue => err
   puts "#{err.class}: #{err.message}".red
+  puts "#{err.backtrace.join("\n")}".yellow if $debug
+  exit 1
 end

data/lib/nephos-server/bin-helpers.rb

@@ -1,4 +1,5 @@
 module Nephos
+
   module Bin
 
     # @param dir [String]
@@ -18,7 +19,45 @@ module Nephos
       return true
     end
 
+    module Daemon
+
+      def self.started?
+        get_pid != nil
+      end
+
+      def self.kill!
+        d = get_pid
+        return false unless d
+        begin
+          Process::kill(10, d)
+        rescue => err
+          raise "Cannot kill #{d} !"
+        ensure
+          File.delete(get_pid_file)
+        end
+        return true
+      end
+
+      def self.detach!
+        Process::daemon(true, false)
+        File.write(get_pid_file, Process::pid.to_s)
+      end
+
+      def self.get_pid_file
+        return ".pid"
+      end
+
+      def self.get_pid
+        return nil if not File.exists?(get_pid_file)
+        v = File.read(get_pid_file)
+        v = Integer(v) rescue nil
+        return v
+      end
+
+    end
+
   end
+
 end
 
 class BinError < StandardError; end

data/lib/nephos-server/controller.rb

@@ -6,28 +6,80 @@ module Nephos
   # and the parameters.
   class Controller
 
-    attr_reader :env, :infos, :callpath, :params, :cookies
-    attr_reader :req
+    attr_reader :req, :callpath, :params, :cookies
 
     # @param env [Hash] env extracted from the http request
     # @param parsed [Hash] pre-parsed env with parameters, ...
-    def initialize env={}, parsed={path: [], params: {}}, callpath={params: []}
-      raise ArgumentError, "env must be a Hash" unless env.is_a? Hash
-      raise ArgumentError, "parsed must be a Hash" unless parsed.is_a? Hash
-      raise ArgumentError, "callpath must be a Hash" unless callpath.is_a? Hash
-      raise ArgumentError, "Invalid Parsed. :path must be associated with an Array" unless parsed[:path].is_a? Array
-      raise ArgumentError, "Invalid Parsed. :params must be associated with a Hash" unless parsed[:params].is_a? Hash
-      raise ArgumentError, "Invalid Callpath. :params must be associated with an Array" unless callpath[:params].is_a? Array
-      @env= env
-      @req= Rack::Request.new(env)
-      @infos= parsed
+    def initialize req, callpath
+      raise ArgumentError, "req must be a Rack::Request" unless req.is_a? Rack::Request
+      raise ArgumentError, "call must be a Hash" unless callpath.is_a? Hash
+      @req= req
       @callpath= callpath
-      @params= parsed[:params]
-      @params.merge! Hash[callpath[:params].zip @infos[:path]]
+      @params= req.params rescue {}
+
+      params = @req.path.split("/")
+      params.shift
+      @params.merge! Hash[callpath[:params].zip(params)]
       @params.select!{|k,v| not k.to_s.empty?}
+
+
       @params = Params.new(@params)
       @cookies = Params.new(@req.cookies)
     end
 
+    @@before_action = {:'*' =>  []}
+    @@after_action = {:'*' =>  []}
+
+    def self.parse_action_opts(opt)
+      if opt.nil?
+        return :'*'
+      elsif opt.is_a? Hash
+        raise "No implemented yet"
+        # parse :only and :except
+      elsif opt.is_a? String or opt.is_a? Symbol
+        return opt.to_sym
+      else
+        raise ArgumentError, "Invalid opts"
+      end
+    end
+
+    # @param method [Symbol]
+    # @param opt [Nil, Hash, String, Symbol] define which method will call "method"
+    #   - if nil, then all call will trigger the event
+    #   - if Hash, it will be parsed with rules :only and :except
+    #   - if String or Symbol, it will be parsed as :only
+    def self.before_action(method, opt=nil)
+      call = parse_action_opts(opt)
+      @@before_action[call] ||= []
+      @@before_action[call] << method.to_sym
+    end
+
+    # see {#self.before_action}
+    def self.after_action(method, opt=nil)
+      call = parse_action_opts(opt)
+      @@after_action[call] ||= []
+      @@after_action[call] << method.to_sym
+    end
+
+    def execute_before_action(call)
+      call = call.to_sym
+      methods = []
+      methods += Array(@@before_action[call])
+      methods += @@before_action[:'*']
+      methods.each do |method|
+        self.send(method)
+      end
+    end
+
+    def execute_after_action(call)
+      call = call.to_sym
+      methods = []
+      methods += Array(@@after_action[call])
+      methods += @@after_action[:'*']
+      methods.each do |method|
+        self.send(method)
+      end
+    end
+
   end
 end

data/lib/nephos-server/params.rb

@@ -33,5 +33,9 @@ module Nephos
       return @hash
     end
 
+    def to_s
+      return to_h.to_s
+    end
+
   end
 end

data/lib/nephos-server/router/load.rb

@@ -1,5 +1,6 @@
 module Nephos
-  module Router
+
+  class Router
 
     def self.add(what, verb)
       Nephos::Router::ROUTES << what.merge(verb: verb)
@@ -9,15 +10,13 @@ module Nephos
     end
 
     # @param what [Hash]
-    #
-    # TODO: doc
     def self.add_params!(what)
       params = what[:url].split('/').map do |p|
         p.match(/:\w+/) ? {p: "[^\/]+", name: p} : {p: p, name: nil}
       end
       url = params.map{|e| e[:p]}.join("/")
       url = "/" if url.empty?
-      what[:match] = /^#{url}$/
+      what[:match] = /^#{url}\/*$/
       what[:params] = params.map{|e| e[:name] && e[:name][1..-1]}[1..-1] || []
     end
 
@@ -35,9 +34,6 @@ module Nephos
 
     # @param what [Hash]
     #
-    # TODO:
-    # - Improve instanciation test
-    #
     # Check if:
     # - the what parameter contains a :controller
     # - this controller exists
@@ -53,7 +49,7 @@ module Nephos
         raise InvalidRouteController, "Class \"#{what[:controller]}\" is not a Nephos::Controller"
       end
       begin
-        instance = controller.new
+        instance = controller.new(Rack::Request.new({}), {params: []})
       rescue => err
         raise InvalidRouteController, "Cannot initialize controller"
       end
@@ -77,6 +73,7 @@ module Nephos
     end
 
   end
+
 end
 
 require_relative 'helpers'

data/lib/nephos-server/router/main.rb

@@ -7,71 +7,59 @@ module Nephos
 
   # The {Router} provides an interface between the {Controller} and the client
   # queries.
-  module Router
+  class Router
 
     ROUTES = []
 
-    # @param args Contain the controller and the method to call on it
-    #
-    # Shortcut to #{Nephos::Responder.render}
-    def self.render *args
-      if args.first.is_a? Nephos::Controller
-        return Responder.render_from_controller *args
-      end
-      return Responder.render *args
+    # @param opt [Hash] it contains optional parameters, via the keys (Symbol only)
+    #   - :silent : if true, then there will be no puts on the stdin when a request is routed.
+    #     Else, or by default, there will be information printed on stdin
+    def initialize(opt={})
+      @responder = Responder.new
+      @silent = !!opt[:silent]
     end
 
-    def self.error(code, err=nil)
-      if ENV["ENVIRONMENT"].to_s.match(/prod(uction)?/)
-        return render(status: code)
+    # render the return of a call to Controller.new.method.
+    # Controller and method are stored on call via the keys :controller and :method
+    def render_controller req, call
+      return @responder.render_from_controller(req, call)
+    end
+
+    def render_error(req, code, err=nil)
+      if Nephos.env == "production"
+        return @responder.render(status: code)
       elsif err
         msg = err
         if msg.is_a? Exception
           msg = err.message + "\n"
-          msg += "--- Backtrace ---\n" + err.backtrace.join("\n") + "\n" if Nephos.env != "production"
+          msg += "--- Backtrace ---\n" + err.backtrace.join("\n") + "\n"
         end
-        return render(status: code,
-                      content: "Error: #{code}\n#{msg}")
+        return @responder.render(status: code, content: "Error: #{code}\n#{msg}")
       else
-        return render(status: code)
+        return @responder.render(status: code)
       end
     end
 
     # @param path [Array]
     #
     # Find the right route to use from the url
-    def self.parse_path path, verb
-      route = File.join(["/"] + path)
-      return ROUTES.find{|e| e[:match] =~ route and e[:verb] == verb}
-    end
-
-    def self.parse_env(env, route)
-      verb = env["REQUEST_METHOD"]
-      from = env["REMOTE_ADDR"]
-      path = route.path.split("/").select{|e|not e.to_s.empty?}
-      params = Rack::Request.new(env).params
-      # Hash[route.query.to_s.split("&").map{|e| e.split("=")}]
-      return {route: route, verb: verb, from: from, path: path, params: params}
+    def find_route req
+      return ROUTES.find{|e| e[:match] =~ req.path and e[:verb] == req.request_method}
     end
 
     # Interface which handle the client query (stored in env), create a new
     # {Controller} instance, and call the render on it
-    def self.execute(env)
-      begin
-        route = URI.parse(env['REQUEST_URI'])
-      rescue => err
-        puts "uri err #{err.message}".red
-        return error(500, err)
-      end
-      parsed = parse_env(env, route)
-      puts "#{parsed[:from]} [#{parsed[:verb]}] \t ---> \t #{route}"
-      call = parse_path(parsed[:path], parsed[:verb])
-      return error(404, "404 not found \"#{route}\"") if call.nil?
+    def execute(req)
+      env = req.env
+      puts "#{req.env["REMOTE_ADDR"]} [#{req.request_method}] \t ---> \t #{req.path}" unless @silent
+      call = find_route(req)
+      return render_error(req, 404, "404 not found \"#{req.path}\"") if call.nil?
       begin
-        controller = Module.const_get(call[:controller]).new(env, parsed, call)
-        return render(controller, call[:method])
+        return render_controller(req, call)
       rescue => err
-        return error(500, err)
+        STDERR.puts "Error: #{err.message}"
+        STDERR.puts err.backtrace
+        return render_error(req, 500, err)
       end
     end
 

data/lib/nephos-server/server/main.rb

@@ -3,19 +3,21 @@ require_relative 'responder'
 module Nephos
   class Server
 
-    SERVER = lambda {|env| return Router.execute(env)}
-
     attr_accessor :port, :host
 
     # @param port [Integer] port to listen
     def initialize port="8080", host="0.0.0.0"
       @port = Integer(port)
       @host = host.to_s
+      @server = lambda {|env|
+        router = Router.new
+        return router.execute(Rack::Request.new(env))
+      }
     end
 
     # start the Rack server
     def start
-      Rack::Server.start :app => SERVER, :Port => @port, :Host => @host
+      Rack::Server.start :app => @server, :Port => @port, :Host => @host
     end
 
     # start the Rack server on a instance of Nephos::Server

data/lib/nephos-server/server/responder.rb

@@ -1,16 +1,17 @@
 module Nephos
-  module Responder
+
+  class Responder
 
     class InvalidContentType < StandardError; end
 
     CT_CHARSET_PREFIX = '; charset='
 
-    def self.content_type(kind, type, charset='UTF-8')
+    def content_type(kind, type, charset='UTF-8')
       "#{kind}/#{type}" + CT_CHARSET_PREFIX + charset
     end
 
     # @param params [Hash] containing :type => "kind/type", example: "text/html"
-    def self.ct_specific(params)
+    def ct_specific(params)
       kind, type = params[:type].to_s.match(/^(\w+)\/(\w+)$/) && Regexp.last_match[1..2]
       if kind.nil? or type.nil?
         raise InvalidContentType, "params[:type] must match with \"kind/type\""
@@ -24,20 +25,19 @@ module Nephos
       json: "application/json",
     }
 
-    private
     # if not :status entry, set to 200
-    def self.set_default_params_status params
+    def set_default_params_status params
       params[:status] ||= 200
     end
 
-    def self.set_default_params_type params
+    def set_default_params_type params
       if params[:type].nil?
         params[:type] = PRESET_CT[(params.keys & [:plain, :html, :json]).first || :plain]
       end
       params[:type] = ct_specific(params)
     end
 
-    def self.set_default_params_content params
+    def set_default_params_content params
       type = (params.keys & [:plain, :html, :json, :content]).first
       if type.nil?
         if params[:status].to_s.match(/^[45]\d\d$/)
@@ -52,37 +52,44 @@ module Nephos
         params[:content] = params[type]
       end
     end
-    public
 
     # Fill params with default parameters (status, plain errors)
-    def self.set_default_params params
+    def set_default_params params
       set_default_params_status(params)
       set_default_params_type(params)
       set_default_params_content(params)
-      params
+      return params
     end
 
-    def self.empty_resp
+    def empty_resp
       resp = Rack::Response.new
       resp.status = 204
       resp["Content-Type"] = ct_specific({type: PRESET_CT[:plain]})
-      resp
+      return resp
     end
 
-    def self.render_from_controller controller, method_to_call
-      params = controller.send method_to_call
-      resp = Responder.render(params)
+    def render_from_controller req, call
+      controller = Module.const_get(call[:controller]).new(req, call)
+      method_to_call = call[:method]
+
+      controller.execute_before_action(method_to_call)
+      # puts "Call #{controller} # #{method_to_call}"
+      params = controller.send(method_to_call)
+      controller.execute_after_action(method_to_call)
+
+      # puts "--- Params #{params.class} ---", "<<", params, ">>"
+      resp = render(params)
       controller.cookies.each do |k, v|
         resp.set_cookie k, v
       end
       return resp
     end
 
-    # @param controller [Controller]
-    # @param method_to_call [Symbol]
-    def self.render params
-      return Responder.empty_resp if params == :empty
+    def render params
+      return empty_resp if params == :empty
       return render(status: params) if params.is_a? Integer
+      raise "Not a valid params argument" unless params.is_a? Hash
+
       resp = Rack::Response.new
       params = set_default_params(params)
       resp.status = params[:status]
@@ -92,4 +99,5 @@ module Nephos
     end
 
   end
+
 end

data/nephos-server.gemspec

@@ -40,7 +40,10 @@ test/responder.rb
 test/router.rb
 test/params.rb
 test/controller.rb
-test/generator.rb
+test/functional.rb
+test/functional/server.rb
+test/functional/generator.rb
+test/functional/global.rb
 routes.rb
 
 app/dataset.rb

data/routes.rb

@@ -17,7 +17,7 @@ get url: "/rm", controller: "MainController", method: "rm_url"
 get url: "/debug", controller: "MainController", method: "debug"
 get url: "/hello", controller: "MainController", method: "hello"
 
-get url: "/image", controller: "MainController", method: "image"
+# get url: "/image", controller: "MainController", method: "image"
 get url: "/image/:image", controller: "MainController", method: "image"
 get url: "img/:image", controller: "MainController", method: "image"
 

data/test/controller.rb

@@ -1,25 +1,30 @@
+class ReqWithWritableParams < Rack::Request
+  def params
+    return Hash[@env["REQUEST_URI"].gsub(/.*\?(.+)/, '\1').split('&').map{|d| d.split('=')}]
+  end
+end
+
 class TestNephosServerController < Test::Unit::TestCase
 
-  def test_initialize_success
-    assert Nephos::Controller.new()
-    assert Nephos::Controller.new(env={}, {path: [], params: {}}, {params: []})
-  end
+  def test_initialize
+    assert_raise do Nephos::Controller.new() end
+    assert_raise do Nephos::Controller.new({}) end
+    assert_raise do Nephos::Controller.new({}, {}) end
 
-  def test_initialize_failure
-    assert_raise do Nephos::Controller.new({}, {}, {}) end
-    assert_raise do Nephos::Controller.new({}, {path: nil}, {}) end
-    assert_raise do Nephos::Controller.new({}, {path: []}, {}) end
-    assert_raise do Nephos::Controller.new({}, {path: [], params: {}}, {}) end
-    assert_raise do Nephos::Controller.new({}, {path: [], params: {}}, {params: nil}) end
-    assert_raise do Nephos::Controller.new({}, {path: nil, params: nil}, params: nil) end
-    assert_raise do Nephos::Controller.new({}, {path: nil, params: {}}, {params: {}}) end
-    assert_raise do Nephos::Controller.new({}, {path: [], params: nil}, {params: {}}) end
+    r = Rack::Request.new({})
+    assert_raise do Nephos::Controller.new() end
+    assert_raise do Nephos::Controller.new(r) end
+    assert_raise do Nephos::Controller.new(r, {}) end
+    assert do Nephos::Controller.new(r, {params: []}) end
   end
 
   def test_controller_params
-    c = Nephos::Controller.new(env={}, {path: ["value"], params: {}}, {params: ["param"]})
-    assert_equal "value", c.params[:param]
-    assert_equal "value", c.params["param"]
+    r = ReqWithWritableParams.new({"REQUEST_METHOD"=>"GET",
+                                   "PATH_INFO"=>"/index",
+                                   "REQUEST_URI"=>"/uri?k=v"})
+    c = Nephos::Controller.new(r, {params: []})
+    assert_equal "v", c.params[:k]
+    assert_equal "v", c.params["k"]
   end
 
 end

data/test/functional.rb

@@ -0,0 +1,9 @@
+require "test/unit"
+
+require_relative "../lib/nephos-server"
+
+require_relative 'functional/generator'
+require_relative 'functional/server'
+require_relative 'functional/global'
+
+require_relative 'functional/router'

data/test/functional/global.rb

@@ -0,0 +1,6 @@
+class TestGlobal < Test::Unit::TestCase
+
+  def test_simpe_requests_on_app
+  end
+
+end

data/test/functional/server.rb

@@ -0,0 +1,37 @@
+class TestNephosServerBinServer < Test::Unit::TestCase
+
+  def test_daemon
+    # WARNING: be sure there is no instance before running theses tests
+
+    # test start and kill
+    `./bin/nephos-server --test -d`
+    assert_equal 0, $?.exitstatus
+    `./bin/nephos-server --test -k`
+    assert_equal 0, $?.exitstatus
+
+    # test kill after killed
+    `./bin/nephos-server --test -k`
+    assert_equal 1, $?.exitstatus
+    `./bin/nephos-server --test -k`
+    assert_equal 1, $?.exitstatus
+
+    # test start after killed
+    `./bin/nephos-server --test -d`
+    assert_equal 0, $?.exitstatus
+
+    # test start after started
+    `./bin/nephos-server --test -d`
+    assert_equal 1, $?.exitstatus
+    `./bin/nephos-server --test -d`
+    assert_equal 1, $?.exitstatus
+
+    # test kill after started N times
+    `./bin/nephos-server --test -k`
+    assert_equal 0, $?.exitstatus
+
+    # test kill after started N times and then killed
+    `./bin/nephos-server --test -k`
+    assert_equal 1, $?.exitstatus
+  end
+
+end

data/test/responder.rb

@@ -3,7 +3,7 @@ class TestNephosServerResponder < Test::Unit::TestCase
   def test_content_type
     assert_equal(
       "KIND/TYPE" "; charset=" "CHARSET",
-      Nephos::Responder.content_type("KIND", "TYPE", "CHARSET")
+      Nephos::Responder.new.content_type("KIND", "TYPE", "CHARSET")
     )
   end
 
@@ -18,16 +18,25 @@ class TestNephosServerResponder < Test::Unit::TestCase
     p7 = {type: []}
     p8 = {type: nil}
     p9 = {}
-    assert Nephos::Responder.ct_specific(p0)
-    assert_raise Nephos::Responder::InvalidContentType do Nephos::Responder.ct_specific(p1) end
-    assert_raise Nephos::Responder::InvalidContentType do Nephos::Responder.ct_specific(p2) end
-    assert_raise Nephos::Responder::InvalidContentType do Nephos::Responder.ct_specific(p3) end
-    assert_raise Nephos::Responder::InvalidContentType do Nephos::Responder.ct_specific(p4) end
-    assert_raise Nephos::Responder::InvalidContentType do Nephos::Responder.ct_specific(p5) end
-    assert_raise Nephos::Responder::InvalidContentType do Nephos::Responder.ct_specific(p6) end
-    assert_raise Nephos::Responder::InvalidContentType do Nephos::Responder.ct_specific(p7) end
-    assert_raise Nephos::Responder::InvalidContentType do Nephos::Responder.ct_specific(p8) end
-    assert_raise Nephos::Responder::InvalidContentType do Nephos::Responder.ct_specific(p9) end
+    assert Nephos::Responder.new.ct_specific(p0)
+    assert_raise Nephos::Responder::InvalidContentType do
+      Nephos::Responder.new.ct_specific(p1) end
+    assert_raise Nephos::Responder::InvalidContentType do
+      Nephos::Responder.new.ct_specific(p2) end
+    assert_raise Nephos::Responder::InvalidContentType do
+      Nephos::Responder.new.ct_specific(p3) end
+    assert_raise Nephos::Responder::InvalidContentType do
+      Nephos::Responder.new.ct_specific(p4) end
+    assert_raise Nephos::Responder::InvalidContentType do
+      Nephos::Responder.new.ct_specific(p5) end
+    assert_raise Nephos::Responder::InvalidContentType do
+      Nephos::Responder.new.ct_specific(p6) end
+    assert_raise Nephos::Responder::InvalidContentType do
+      Nephos::Responder.new.ct_specific(p7) end
+    assert_raise Nephos::Responder::InvalidContentType do
+      Nephos::Responder.new.ct_specific(p8) end
+    assert_raise Nephos::Responder::InvalidContentType do
+      Nephos::Responder.new.ct_specific(p9) end
   end
 
   def test_set_default_params_status
@@ -35,10 +44,10 @@ class TestNephosServerResponder < Test::Unit::TestCase
     p2 = {status: 300}
     p3 = {status: nil}
     p4 = {}
-    Nephos::Responder.set_default_params_status(p1)
-    Nephos::Responder.set_default_params_status(p2)
-    Nephos::Responder.set_default_params_status(p3)
-    Nephos::Responder.set_default_params_status(p4)
+    Nephos::Responder.new.set_default_params_status(p1)
+    Nephos::Responder.new.set_default_params_status(p2)
+    Nephos::Responder.new.set_default_params_status(p3)
+    Nephos::Responder.new.set_default_params_status(p4)
     assert_equal({status: 200}, p1)
     assert_equal({status: 300}, p2)
     assert_equal({status: 200}, p3)
@@ -46,15 +55,15 @@ class TestNephosServerResponder < Test::Unit::TestCase
   end
 
   def test_set_default_params_type_1
-    p_ref = {type: Nephos::Responder.ct_specific({type: "text/plain"})}
+    p_ref = {type: Nephos::Responder.new.ct_specific({type: "text/plain"})}
     p1 = {type: "text/plain"}
     p2 = {type: "text"}
     p3 = {type: "text/plain"}
-    Nephos::Responder.set_default_params_type(p1)
+    Nephos::Responder.new.set_default_params_type(p1)
     assert_equal p1, p_ref
     assert_raise Nephos::Responder::InvalidContentType do
-      Nephos::Responder.set_default_params_type(p2) end
-    Nephos::Responder.set_default_params_type(p3)
+      Nephos::Responder.new.set_default_params_type(p2) end
+    Nephos::Responder.new.set_default_params_type(p3)
     assert_equal p_ref, p3
   end
 
@@ -64,14 +73,14 @@ class TestNephosServerResponder < Test::Unit::TestCase
     p3 = {json: "bla", plain: "bla"}
     p4 = {json: "bla", html: "bla"}
     p5 = {json: "bla"}
-    Nephos::Responder.set_default_params_type(p1)
-    Nephos::Responder.set_default_params_type(p2)
-    Nephos::Responder.set_default_params_type(p3)
-    Nephos::Responder.set_default_params_type(p4)
-    Nephos::Responder.set_default_params_type(p5)
-    plain = Nephos::Responder.ct_specific({type: "text/plain"})
-    json = Nephos::Responder.ct_specific({type: "application/json"})
-    html = Nephos::Responder.ct_specific({type: "text/html"})
+    Nephos::Responder.new.set_default_params_type(p1)
+    Nephos::Responder.new.set_default_params_type(p2)
+    Nephos::Responder.new.set_default_params_type(p3)
+    Nephos::Responder.new.set_default_params_type(p4)
+    Nephos::Responder.new.set_default_params_type(p5)
+    plain = Nephos::Responder.new.ct_specific({type: "text/plain"})
+    json = Nephos::Responder.new.ct_specific({type: "application/json"})
+    html = Nephos::Responder.new.ct_specific({type: "text/html"})
     assert_equal plain, p1[:type]
     assert_equal html, p2[:type]
     assert_equal json, p3[:type]
@@ -80,13 +89,13 @@ class TestNephosServerResponder < Test::Unit::TestCase
   end
 
   def test_render_simple
-    r1 = Nephos::Responder.render(:empty)
-    r2 = Nephos::Responder.render(200)
-    r3 = Nephos::Responder.render(201)
-    r4 = Nephos::Responder.render(status: 202)
-    r5 = Nephos::Responder.render(plain: "")
-    r6 = Nephos::Responder.render(json: "")
-    r7 = Nephos::Responder.render(html: "")
+    r1 = Nephos::Responder.new.render(:empty)
+    r2 = Nephos::Responder.new.render(200)
+    r3 = Nephos::Responder.new.render(201)
+    r4 = Nephos::Responder.new.render(status: 202)
+    r5 = Nephos::Responder.new.render(plain: "")
+    r6 = Nephos::Responder.new.render(json: "")
+    r7 = Nephos::Responder.new.render(html: "")
     assert_equal(204, r1.status)
     assert_equal(200, r2.status)
     assert_equal(201, r3.status)
@@ -97,9 +106,9 @@ class TestNephosServerResponder < Test::Unit::TestCase
   end
 
   def test_render_advanced
-    r1 = Nephos::Responder.render(status: 201, plain: "plaaaain")
-    r2 = Nephos::Responder.render(status: 201, json: {data: [1, 2]})
-    r3 = Nephos::Responder.render(status: 201, html: "<p>p</p>")
+    r1 = Nephos::Responder.new.render(status: 201, plain: "plaaaain")
+    r2 = Nephos::Responder.new.render(status: 201, json: {data: [1, 2]})
+    r3 = Nephos::Responder.new.render(status: 201, html: "<p>p</p>")
     assert_equal(201, r1.status)
     assert_equal("text/plain; charset=UTF-8", r1["Content-type"])
     assert_equal(["plaaaain"], r1.body)

data/test/router.rb

@@ -20,6 +20,21 @@ class TestNephosServerRouter < Test::Unit::TestCase
     Nephos::Router::ROUTES.first
   end
 
+  def test_init_router
+    r1= Nephos::Router.new
+    r2= Nephos::Router.new({})
+    r3= Nephos::Router.new({silent: false})
+    r4= Nephos::Router.new({silent: true})
+    assert r1
+    assert_equal(false, r1.instance_variable_get(:@silent))
+    assert r2
+    assert_equal(false, r2.instance_variable_get(:@silent))
+    assert r3
+    assert_equal(false, r3.instance_variable_get(:@silent))
+    assert r4
+    assert_equal(true, r4.instance_variable_get(:@silent))
+  end
+
   def test_multi_routes
     reset_routes!
     get url: "/a", controller: "TestController", method: "method", silent: true
@@ -44,7 +59,7 @@ class TestNephosServerRouter < Test::Unit::TestCase
     assert_equal "GET", first[:verb]
     assert_equal "TestController", first[:controller]
     assert_equal "method", first[:method]
-    assert_equal /^\/$/, first[:match]
+    assert_equal /^\/\/*$/, first[:match]
 
     reset_routes!
     post url: "/", controller: "TestController", method: "method", silent: true
@@ -52,7 +67,7 @@ class TestNephosServerRouter < Test::Unit::TestCase
     assert_equal "POST", first[:verb]
     assert_equal "TestController", first[:controller]
     assert_equal "method", first[:method]
-    assert_equal /^\/$/, first[:match]
+    assert_equal /^\/\/*$/, first[:match]
 
     reset_routes!
     put url: "/", controller: "TestController", method: "method", silent: true
@@ -60,14 +75,14 @@ class TestNephosServerRouter < Test::Unit::TestCase
     assert_equal "PUT", first[:verb]
     assert_equal "TestController", first[:controller]
     assert_equal "method", first[:method]
-    assert_equal /^\/$/, first[:match]
+    assert_equal /^\/\/*$/, first[:match]
   end
 
   def test_valid_routes_params
     reset_routes!
     get url: "/:what", controller: "TestController", method: "method", silent: true
     assert_equal "/:what", first[:url]
-    assert_equal /^\/[^\/]+$/, first[:match]
+    assert_equal /^\/[^\/]+\/*$/, first[:match]
   end
 
   def test_valid_resources
@@ -87,7 +102,7 @@ class TestNephosServerRouter < Test::Unit::TestCase
       get url: "/:what", controller: "TestController", method: "method", silent: true
     end
     assert_equal "/home/:what", first[:url]
-    assert_equal /^\/home\/[^\/]+$/, first[:match]
+    assert_equal /^\/home\/[^\/]+\/*$/, first[:match]
   end
 
   def test_valid_resources_params2
@@ -96,46 +111,75 @@ class TestNephosServerRouter < Test::Unit::TestCase
       get url: "/show", controller: "TestController", method: "method", silent: true
     end
     assert_equal "/:id/show", first[:url]
-    assert_equal /^\/[^\/]+\/show$/, first[:match]
+    assert_equal /^\/[^\/]+\/show\/*$/, first[:match]
   end
 
+  REQ_GET_INDEX = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/index"})
+  REQ_POST_INDEX = Rack::Request.new({"REQUEST_METHOD"=>"POST", "PATH_INFO"=>"/index"})
+  REQ_PUT_INDEX = Rack::Request.new({"REQUEST_METHOD"=>"PUT", "PATH_INFO"=>"/index"})
+  REQ_GET_INDEXX = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/indexx"})
+  REQ_GET_INDE = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/inde"})
+
   def test_routing_matching_simple
     reset_routes!
     get url: "/index", controller: "TestController", method: "method", silent: true
     post url: "/index", controller: "TestController", method: "method", silent: true
-    assert(Nephos::Router::parse_path(["index"], "GET"))
-    assert(Nephos::Router::parse_path(["index"], "POST"))
-    assert(Nephos::Router::parse_path(["index"], "PUT") == nil)
-    assert(Nephos::Router::parse_path(["indexx"], "GET") == nil)
-    assert(Nephos::Router::parse_path(["inde"], "GET") == nil)
+    assert(Nephos::Router.new.find_route(REQ_GET_INDEX))
+    assert(Nephos::Router.new.find_route(REQ_POST_INDEX))
+    assert(!Nephos::Router.new.find_route(REQ_PUT_INDEX))
+    assert(!Nephos::Router.new.find_route(REQ_GET_INDEXX))
+    assert(!Nephos::Router.new.find_route(REQ_GET_INDE))
   end
 
+  REQ_GET_ID_INDEX = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/id/index"})
+  REQ_GET_XXX_INDEX = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/XXX/index"})
+  REQ_GET_ID = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/id"})
+  REQ_GET_XXX = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/XXX"})
+  REQ_GET_INDEX_ID = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/index/id"})
+
   def test_routing_matching_simple_with_arguments1
     reset_routes!
     get url: "/:id", controller: "TestController", method: "method1", silent: true
     get url: "/:id/index", controller: "TestController", method: "method2", silent: true
-    assert(Nephos::Router::parse_path(["id", "index"], "GET"))
-    assert(Nephos::Router::parse_path(["XXX", "index"], "GET"))
-    assert(Nephos::Router::parse_path(["id"], "GET"))
-    assert(Nephos::Router::parse_path(["XXX"], "GET"))
-    assert(Nephos::Router::parse_path(["index", "id"], "GET") == nil)
+    assert(Nephos::Router.new.find_route(REQ_GET_ID_INDEX))
+    assert(Nephos::Router.new.find_route(REQ_GET_XXX_INDEX))
+    assert(Nephos::Router.new.find_route(REQ_GET_ID))
+    assert(Nephos::Router.new.find_route(REQ_GET_XXX))
+    assert(!Nephos::Router.new.find_route(REQ_GET_INDEX_ID))
   end
 
+  REQ_GET_IDX_INDEX = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/idx/index"})
+  REQ_GET_XXX_INDEX = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/XXX/index"})
+  REQ_GET_ID = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/id"})
+  REQ_GET_XXX = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/XXX"})
+
+  REQ_GET_INDEX_ID = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/index/id"})
+  REQ_GET_INDEX_XXX = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/index/XXX"})
+  REQ_POST_INDEX_XXX_INDEX = Rack::Request.new({"REQUEST_METHOD"=>"POST", "PATH_INFO"=>"/index/XXX/index"})
+
+  REQ_GET_INDEX_XXX_INDEX = Rack::Request.new({"REQUEST_METHOD"=>"GET", "PATH_INFO"=>"/index/XXX/index"})
+  REQ_POST_INDEX_XXX_ID = Rack::Request.new({"REQUEST_METHOD"=>"POST", "PATH_INFO"=>"/index/XXX/id"})
+  REQ_POST_INDEX_XXX_XXX = Rack::Request.new({"REQUEST_METHOD"=>"POST", "PATH_INFO"=>"/index/XXX/XXX"})
+
+  # TODO : FIX
   def test_routing_matching_simple_with_arguments2
     reset_routes!
     get url: "/index", controller: "TestController", method: "method1", silent: true
     get url: "/index/:id", controller: "TestController", method: "method1", silent: true
     post url: "/index/:id/index", controller: "TestController", method: "method2", silent: true
-    assert(Nephos::Router::parse_path(["id", "index"], "GET") == nil)
-    assert(Nephos::Router::parse_path(["XXX", "index"], "GET") == nil)
-    assert(Nephos::Router::parse_path(["id"], "GET") == nil)
-    assert(Nephos::Router::parse_path(["XXX"], "GET") == nil)
-    assert(Nephos::Router::parse_path(["index", "id"], "GET"))
-    assert(Nephos::Router::parse_path(["index", "XXX"], "GET"))
-    assert(Nephos::Router::parse_path(["index", "XXX", "index"], "POST"))
-    assert(Nephos::Router::parse_path(["index", "XXX", "index"], "GET") == nil)
-    assert(Nephos::Router::parse_path(["index", "XXX", "id"], "POST") == nil)
-    assert(Nephos::Router::parse_path(["index", "XXX", "XXX"], "POST") == nil)
+
+    assert(!Nephos::Router.new.find_route(REQ_GET_IDX_INDEX))
+    assert(!Nephos::Router.new.find_route(REQ_GET_XXX_INDEX))
+    assert(!Nephos::Router.new.find_route(REQ_GET_ID))
+    assert(!Nephos::Router.new.find_route(REQ_GET_XXX))
+
+    assert(Nephos::Router.new.find_route(REQ_GET_INDEX_ID))
+    assert(Nephos::Router.new.find_route(REQ_GET_INDEX_XXX))
+    assert(Nephos::Router.new.find_route(REQ_POST_INDEX_XXX_INDEX))
+
+    assert(!Nephos::Router.new.find_route(REQ_GET_INDEX_XXX_INDEX))
+    assert(!Nephos::Router.new.find_route(REQ_POST_INDEX_XXX_ID))
+    assert(!Nephos::Router.new.find_route(REQ_POST_INDEX_XXX_XXX))
   end
 
 end

data/test/test.rb

@@ -6,4 +6,3 @@ require_relative 'responder'
 require_relative 'router'
 require_relative 'controller'
 require_relative 'params'
-require_relative 'generator'

data/version

@@ -1 +1 @@
-0.5.4
+0.6.1

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nephos-server
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.1
 platform: ruby
 authors:
 - poulet_a
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-26 00:00:00.000000000 Z
+date: 2015-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nomorebeer
@@ -109,7 +109,10 @@ files:
 - nephos-server.gemspec
 - routes.rb
 - test/controller.rb
-- test/generator.rb
+- test/functional.rb
+- test/functional/generator.rb
+- test/functional/global.rb
+- test/functional/server.rb
 - test/params.rb
 - test/responder.rb
 - test/router.rb
@@ -138,7 +141,7 @@ rubyforge_project:
 rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
-summary: "* fix regression on empty response * add unitary tests * improve gemspec
-  * fix severe regression on responder * fix environment bug"
+summary: "* Improve daemons * Improve Rakefile and tests structure * Add few functional
+  (router, server, generator) tests * Add new unitary tests"
 test_files: []
 has_rdoc: