rhcp 0.1.2

data/test/rhcp/command_test.rb

@@ -0,0 +1,136 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'rhcp'
+
+class CommandTest < Test::Unit::TestCase
+  
+  def command_method(request, response)
+    first_param = request.get_param_value("first_param")
+    puts "just testing : #{first_param}"    
+    first_param.reverse
+  end
+  
+  def command_method_with_error(request, response)
+    raise "got a problem here!"
+  end
+  
+  def test_construction
+    command = RHCP::Command.new("test", "a command for testing", self.method(:command_method))
+    assert_not_nil command
+    assert_equal "test", command.name
+    assert_equal "a command for testing", command.description
+    assert_not_nil command.params
+    assert_instance_of Hash, command.params
+    assert_equal 0, command.params.size
+    
+    command.add_param(RHCP::CommandParam.new("first_param", "this is the first param"))
+    command.add_param(RHCP::CommandParam.new("second_param", "this is the second param"))
+    assert_equal 2, command.params.size
+    first_param = command.get_param("first_param")
+    assert_not_nil first_param
+    assert_equal "first_param", first_param.name
+    assert_equal "this is the first param", first_param.description
+    assert_raise(RHCP::RhcpException) { command.get_param("does not exist") }
+  end
+  
+  def test_execute_request
+    command = RHCP::Command.new("test", "a command for testing", self.method(:command_method))
+    command.add_param(RHCP::CommandParam.new("first_param", "this is the first param"))
+    request = RHCP::Request.new(command, { "first_param" => [ "the_value" ] })
+    response = command.execute_request(request) 
+    assert_equal "the_value".reverse, response.data
+    assert_equal RHCP::Response::Status::OK, response.status
+  end
+  
+  def test_execute_error
+    command = RHCP::Command.new("not working", "told you so", self.method(:command_method_with_error))
+    request = RHCP::Request.new(command, {})
+    response = command.execute_request(request)
+    assert_equal RHCP::Response::Status::ERROR, response.status
+  end
+  
+  def test_execute
+    command = RHCP::Command.new("test", "a command for testing", self.method(:command_method))
+    command.add_param(RHCP::CommandParam.new("first_param", "this is the first param"))
+    response = command.execute({"first_param" => "thing"})
+    assert_equal "thing".reverse, response.data    
+  end
+  
+  def test_duplicate_params
+    command = RHCP::Command.new("test_duplicate", "command for testing param duplicates", lambda {})
+    command.add_param(RHCP::CommandParam.new("first_param", "first param"))
+    assert_raise(RuntimeError) { command.add_param(RHCP::CommandParam.new("first_param", "i am a duplicate")) }
+  end
+  
+  # it should not be possible to add more than one default param
+  def test_multiple_default_params
+    command = RHCP::Command.new("test", "command for testing multiple default params", lambda {})
+    command.add_param RHCP::CommandParam.new("first_param", "first param", 
+        {
+          :is_default_param => true
+        }
+    )
+    assert_raise(RHCP::RhcpException) {
+      command.add_param RHCP::CommandParam.new("second_param", "second default param", 
+        {
+          :is_default_param => true
+        }
+      ) 
+    }
+  end
+  
+  def test_get_default_param
+    command = RHCP::Command.new("test_duplicate", "command for testing get_default_param", lambda {})
+    assert_nil command.default_param
+    the_param = RHCP::CommandParam.new("first_param", "first param", 
+        {
+          :is_default_param => true
+        }
+    )
+    command.add_param the_param
+    assert_equal the_param, command.default_param
+  end
+  
+  def test_listener
+    command = RHCP::Command.new("test_listener", "just some dumb command for the listener", lambda {
+      |req,res|
+      puts "While I think there could be something important to say right now, I just cannot remember what it might have been..."
+      res.result_text = "the test is working."
+    })
+    
+    @listener1_fired = false
+    @listener2_fired = false
+    
+    RHCP::Command.clear_post_exec_listeners()
+    RHCP::Command.register_post_exec_listener(lambda { |req,res| @listener1_fired = true })
+    RHCP::Command.register_post_exec_listener(lambda { |req,res| @listener2_fired = true })    
+    
+    command.execute()
+    
+    assert @listener1_fired
+    assert @listener2_fired
+  end
+  
+  def test_failing_listener
+    command = RHCP::Command.new("test_listener", "just some dumb command for the listener", lambda {
+      |req,res|
+      puts "While I think there could be something important to say right now, I just cannot remember what it might have been..."
+      res.result_text = "the test is working"
+    })
+  
+    RHCP::Command.clear_post_exec_listeners()
+    RHCP::Command.register_post_exec_listener(lambda { |req,res| raise "this listener is dying"})
+    
+    @listener1_fired = false
+    @listener2_fired = false
+    
+    response = command.execute()
+    assert_not_nil response
+    assert_equal "the test is working", response.result_text
+    assert ! @listener1_fired
+    assert ! @listener2_fired
+  end
+
+end
+

data/test/rhcp/dispatching_broker_test.rb

@@ -0,0 +1,41 @@
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+#require 'rhcp/dispatching_broker'
+#require 'rhcp/broker'
+#require 'rhcp/command'
+#require 'rhcp/command_param'
+require 'rhcp'
+
+class DispatchingBrokerTest < Test::Unit::TestCase
+  
+  def setup
+    @broker1 = RHCP::Broker.new()
+    @broker1.register_command RHCP::Command.new("test", "just testing (broker1)", lambda{})
+    @broker1.register_command RHCP::Command.new("test_more", "another fancy command from broker1", lambda{})
+    @broker2 = RHCP::Broker.new()
+    @broker2.register_command RHCP::Command.new("echo", "says hello (broker2)", lambda{})
+    @broker2.register_command RHCP::Command.new("help", "is no help at all (broker2)", lambda{})
+    @broker2.register_command RHCP::Command.new("red button", "don't press it (broker2)", lambda{})
+  end
+  
+  def test_add_brokers
+    dispatcher = RHCP::DispatchingBroker.new()
+    assert_not_nil dispatcher
+    assert_equal 0, dispatcher.get_command_list.size
+    dispatcher.add_broker(@broker1)
+    assert_equal 2, dispatcher.get_command_list.size
+    dispatcher.add_broker(@broker2)    
+    assert_equal 5, dispatcher.get_command_list.size
+  end
+  
+  def test_duplicate_commands
+    dispatcher = RHCP::DispatchingBroker.new()
+    dispatcher.add_broker(@broker1)
+    assert_equal 2, dispatcher.get_command_list.size
+    assert_raise(RHCP::RhcpException) { dispatcher.add_broker(@broker1) }
+  end
+  
+end
+

data/test/rhcp/http_exporter_test.rb

@@ -0,0 +1,113 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'net/http'
+
+require 'rhcp'
+
+class HttpExporterTest < Test::Unit::TestCase
+  
+  
+  def self.suite    
+    puts "gonna setup"
+    broker = RHCP::Broker.new()
+    broker.register_command(RHCP::Command.new("test", "just a test command", lambda { |req,res| "testing" }))
+    broker.register_command(
+      RHCP::Command.new("reverse", "reversing input strings", 
+        lambda { |req,res| req.get_param_value("input").reverse }
+      ).add_param(RHCP::CommandParam.new("input", "the string to reverse", { 
+            :lookup_method => lambda { [ "zaphod", "beeblebrox" ] } 
+        }))
+    )
+    
+    @@broker = broker
+
+    # TODO test other setup options
+    @@exporter = RHCP::HttpExporter.new(broker, :port => 42000)
+    @@exporter.start()    
+    super
+  end
+  
+  def setup
+    @url = URI.parse("http://localhost:42000")
+  end
+  
+  def teardown
+    #@@exporter.stop
+  end
+  
+  def test_available    
+    res = Net::HTTP.new(@url.host, @url.port).start { |http| http.get("/rhcp/") }   
+    assert_equal "200", res.code
+  end
+  
+#  def test_info
+#    sleep 2
+#    res = Net::HTTP.new(@url.host, @url.port).start { |http| http.get("/rhcp/info/index2.html") }   
+#    
+#    puts res.body
+#    assert_equal "200", res.code
+#  end
+  
+  def test_get_commands
+    res = Net::HTTP.new(@url.host, @url.port).start { |http| http.get("/rhcp/get_commands") }   
+    
+    assert_equal "200", res.code
+    commands = JSON.parse(res.body)
+    
+    # +commands+ is an array => convert it back to a has
+    command_hash = Hash.new()
+    commands.each do |command_string|
+      command = RHCP::Client::CommandStub.reconstruct_from_json(command_string)
+      command_hash[command.name] = command
+    end
+    
+    assert_equal [ "test", "reverse" ].sort, command_hash.keys.sort
+    assert_kind_of RHCP::Command, command_hash["reverse"]
+  end
+  
+  def test_get_lookup_values
+    res = Net::HTTP.new(@url.host, @url.port).start { |http| http.get("/rhcp/get_lookup_values?command=reverse&param=input") }   
+    puts res.body
+    assert_equal "200", res.code
+    lookups = JSON.parse(res.body)
+    assert_equal [ "zaphod", "beeblebrox" ].sort, lookups.sort    
+  end
+  
+  def test_get_lookup_values_invalid_command
+    res = Net::HTTP.new(@url.host, @url.port).start { |http| http.get("/rhcp/get_lookup_values?command=do_the_twist") }   
+    puts "error response #{res.body}"
+    assert_equal "500", res.code
+    result = JSON.parse(res.body)
+    assert(/^no such command/.match(result[0]))
+  end
+  
+  def test_get_lookup_values_without_params
+    res = Net::HTTP.new(@url.host, @url.port).start { |http| http.get("/rhcp/get_lookup_values") }   
+    puts "error response #{res.body}"
+    assert_equal "500", res.code    
+  end
+  
+  def test_get_lookup_values_partial
+    res = Net::HTTP.new(@url.host, @url.port).start { |http| http.get("/rhcp/get_lookup_values?command=reverse&param=input&partial=zap") }   
+    puts res.body
+    assert_equal "200", res.code
+    lookups = JSON.parse(res.body)
+    assert_equal [ "zaphod" ].sort, lookups.sort
+  end
+
+  def test_execute
+    request = RHCP::Request.new(@@broker.get_command("reverse"), {
+      "input" => [ "zaphod" ]
+    })
+    
+    res = Net::HTTP.new(@url.host, @url.port).start { |http| http.post("/rhcp/execute", request.to_json) }
+    puts "execute response #{res.body}"    
+    assert_equal "200", res.code    
+  end
+  
+  def test_execute_fails
+    # TODO write test
+  end
+  
+end

data/test/rhcp/http_registry_test.rb

@@ -0,0 +1,73 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'rhcp'
+
+class HttpBrokerTest < Test::Unit::TestCase
+  
+  def self.suite    
+    # setup an http exporter we can connect to
+    puts "gonna setup"
+    broker = RHCP::Broker.new()
+    @@command_test = RHCP::Command.new("test", "just a test command", lambda { |req,res| "testing" })
+    broker.register_command @@command_test
+
+    @@command_reverse = RHCP::Command.new("reverse", "reversing input strings", 
+        lambda { |req,res| 
+          req.get_param_value("input").reverse 
+        }
+        ).add_param(RHCP::CommandParam.new("input", "the string to reverse", 
+            { 
+              :lookup_method => lambda { [ "zaphod", "beeblebrox" ] } 
+            }
+        )
+    )
+    broker.register_command @@command_reverse
+
+    @@exporter = RHCP::HttpExporter.new(broker, :port => 42001)
+    @@exporter.start()
+    super
+  end    
+  
+  def setup
+    url = URI.parse("http://localhost:42001")
+    @http_broker = RHCP::Client::HttpBroker.new(url)
+    assert_not_nil @http_broker
+  end
+  
+  def test_get_commands
+    commands = @http_broker.get_command_list
+    assert_not_nil commands
+    assert 2, commands.size
+    assert @@command_test, commands["test"]
+    assert @@command_reverse, commands["reverse"]
+    puts "command reverse : >>#{commands["reverse"]}<<"
+  end
+  
+  # the CommandParam should be wrapped in a way that we can retrieve lookup values
+  def test_get_lookup_values
+    command = @http_broker.get_command_list["reverse"]
+    param = command.get_param("input")
+    assert_equal [ "zaphod", "beeblebrox" ], param.get_lookup_values()
+  end
+  
+  def test_execute
+    command = @http_broker.get_command_list["reverse"]
+    assert_instance_of RHCP::Client::CommandStub, command
+    collected_params = {
+      "input" => [ "zaphod" ]
+    }
+    request = RHCP::Request.new(command, collected_params)
+    response = command.execute_request(request)
+    assert_not_nil response
+    assert_equal RHCP::Response::Status::OK, response.status
+    assert_equal "dohpaz", response.data
+  end
+  
+  
+end

data/test/rhcp/http_test_server.rb

@@ -0,0 +1,47 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'rhcp'
+
+require 'net/http'
+require 'logger'
+
+$logger = Logger.new($stdout)
+
+broker = RHCP::Broker.new()
+broker.register_command(RHCP::Command.new("test", "just a test command", lambda { |req,res| "testing" }))
+broker.register_command(
+  RHCP::Command.new("reverse", "reversing input strings", 
+    lambda { |req,res| req.get_param_value("input").reverse }
+  ).add_param(RHCP::CommandParam.new("input", "the string to reverse", { 
+        :lookup_method => lambda { [ "zaphod", "beeblebrox" ] } 
+    }))
+)
+broker.register_command RHCP::Command.new("cook", "cook something nice out of some ingredients", 
+  lambda { |req,res| 
+    ingredients = req.get_param_value("ingredient").join(" ")
+    puts "cooking something with #{ingredients}"
+    ingredients
+  }
+  ).add_param(RHCP::CommandParam.new("ingredient", "something to cook with", 
+      { 
+        :lookup_method => lambda { [ "mascarpone", "chocolate", "eggs", "butter", "marzipan" ] },
+        :allows_multiple_values => true,
+        :mandatory => true
+      }
+  )
+)
+
+exporter = RHCP::HttpExporter.new(broker, :port => 42000)
+
+trap("INT") {
+  exporter.stop
+  Kernel.exit 0
+}
+
+$logger.info "launching http exporter..."
+exporter.start()
+while (true) do
+  sleep 30
+  puts "."
+end
+$logger.info "exiting"

data/test/rhcp/request_test.rb

@@ -0,0 +1,124 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'rhcp'
+
+require 'rubygems'
+require 'json'
+
+class RequestTest < Test::Unit::TestCase
+
+  def test_construction
+    command = RHCP::Command.new("test", "a test", nil)
+    assert_raise(RHCP::RhcpException) { RHCP::Request.new(nil, Hash.new()) }
+    request = RHCP::Request.new(command, Hash.new())
+    assert_not_nil request
+  end
+  
+  def test_get_param_value
+    command = RHCP::Command.new("test", "a test", nil)
+    command.add_param(RHCP::CommandParam.new("first_param", "this is the first param"))
+    command.add_param(RHCP::CommandParam.new("second_param", "this is the second param", { :allows_multiple_values => true }))
+    request = RHCP::Request.new(
+      command, 
+      { 
+        "first_param" => ["foo"],
+        "second_param" => ["foo", "bar", "baz"]
+      }
+    )
+    assert_not_nil request
+    assert_equal "foo", request.get_param_value("first_param")
+    assert_equal ["foo", "bar", "baz"], request.get_param_value("second_param")
+  end
+  
+  def test_has_param_value
+    command = RHCP::Command.new("test", "a test", nil)
+    command.add_param(RHCP::CommandParam.new("first_param", "this is the first param"))
+    command.add_param(RHCP::CommandParam.new("second_param", "this is the second param", { :allows_multiple_values => true }))
+    request = RHCP::Request.new(
+      command, 
+      { 
+        "first_param" => ["foo"],
+        "second_param" => ["foo", "bar", "baz"]
+      }
+    )
+    assert request.has_param_value("first_param")
+    assert ! request.has_param_value("third_param")
+  end
+  
+  def test_invalid_param_name
+    command = RHCP::Command.new("test", "another test", lambda {})
+    command.add_param(RHCP::CommandParam.new("real_param", "this param does exist"))
+    assert_not_nil RHCP::Request.new(command, { "real_param" =>  [ "value for the real param" ] })
+    assert_raise(RHCP::RhcpException) { RHCP::Request.new(command, { 
+          "does_not_exist" =>  [ "single value for non-existing param" ]
+    }) }
+  end
+  
+  def test_invalid_param_values
+    command = RHCP::Command.new("test", "another test", lambda {})
+    command.add_param(RHCP::CommandParam.new("real_param", "this param does exist"))
+    assert_raise(RHCP::RhcpException) { RHCP::Request.new(command, { 
+          "real_param" =>  [ "value for the real param", "another value for the real param" ]
+    }) }
+  end
+  
+  def test_missing_mandatory_param
+    command = RHCP::Command.new("test", "another test", lambda {})
+    command.add_param(RHCP::CommandParam.new("first_param", "this is the first param", { :mandatory => true }))
+    command.add_param(RHCP::CommandParam.new("second_param", "this param is optional", { :mandatory => false }))
+    
+    # test1 : we should not have to specify optional parameters
+    assert_not_nil RHCP::Request.new(command, { "first_param" => [ "bla" ]})
+    
+    # test2 : but we need to specify mandatory params
+    assert_raise(RHCP::RhcpException) { RHCP::Request.new(command, {})}
+  end
+  
+  def test_json
+    command = RHCP::Command.new("request_test", "a test", nil)
+    command.add_param(RHCP::CommandParam.new("first_param", "this is the first param"))
+    command.add_param(RHCP::CommandParam.new("second_param", "this is the second param", { :allows_multiple_values => true }))
+    broker = RHCP::Broker.new()
+    broker.register_command(command)
+    r= RHCP::Request.new(
+      command,
+      { 
+        "first_param" => ["foo"],
+        "second_param" => ["foo", "bar", "baz"]
+      }
+    )
+    json = r.to_json
+    puts "request as JSON : >>#{json}<<"
+    assert_not_nil json
+    r2 = RHCP::Request.reconstruct_from_json(broker, json)
+    assert_instance_of RHCP::Request, r2
+    assert_equal r.command, r2.command
+    assert_equal r.param_values, r2.param_values
+  end
+  
+  def test_execute
+    command = RHCP::Command.new("request_test", "a test", lambda { |req,res| "jehova" })    
+    r= RHCP::Request.new(
+      command
+    )
+    res = r.execute
+    assert_not_nil res
+    assert_equal "jehova", res.data
+  end
+  
+  def test_execute_with_params
+    command = RHCP::Command.new("request_test", "a test", lambda { |req,res| "***" + req.get_param_value("first_one") + "***" }
+    ).add_param(RHCP::CommandParam.new("first_one", "pole position"))
+    r= RHCP::Request.new(
+      command,
+      {
+        "first_one" => "lucky bastard"
+      }
+    )
+    res = r.execute()
+    assert_not_nil res
+    assert_equal "***lucky bastard***", res.data
+  end
+  
+end

data/test/rhcp/response_test.rb

@@ -0,0 +1,45 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'rhcp/response'
+
+class ResponseTest < Test::Unit::TestCase
+  
+  def test_simple
+    response = RHCP::Response.new()
+    assert_not_nil response
+    response.mark_as_error("something went wrong")
+    assert_equal "something went wrong", response.error_text
+    assert_equal "", response.error_detail    
+  end
+  
+  def test_payload
+    response = RHCP::Response.new()
+    assert_not_nil response
+    response.set_payload("some data")
+    assert_equal "some data", response.data
+  end
+  
+  def test_json
+    response = RHCP::Response.new()    
+    response.set_payload("some data")
+    response.mark_as_error("something went wrong", "things got really fucked up")
+    
+    json = response.to_json()
+    assert_not_nil json
+    r2 = RHCP::Response.reconstruct_from_json(json)
+    #r2 = JSON.parse(json)
+    assert_not_nil r2
+    assert_instance_of RHCP::Response, r2
+    assert_equal RHCP::Response::Status::ERROR, r2.status
+    assert_equal "something went wrong", r2.error_text
+    assert_equal "things got really fucked up", r2.error_detail
+    assert_equal "some data", r2.data
+  end
+  
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: rhcp
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+date: 2008-12-07 00:00:00 +01:00
+summary: Library for exporting parts of your application using the rhcp protocol
+require_paths: 
+- lib
+email: philipp@hitchhackers.net
+homepage: http://hitchhackers.net/projects/rhcp
+rubyforge_project: rhcp
+description: The rhcp protocol allows you to register commands along with their parameter descriptions and some metadata that can then be executed by rhcp clients.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: |+
+  
+      This is the initial release of rhcp - hope you'll like it.
+      Feel free to send me feedback to rhcp at hitchhackers dot net.
+  
+authors: 
+- Philipp Traeder
+files: 
+- Rakefile
+- lib/rhcp
+- lib/rhcp/client
+- lib/rhcp/client/http_broker.rb
+- lib/rhcp/client/command_param_stub.rb
+- lib/rhcp/client/command_stub.rb
+- lib/rhcp/command.rb
+- lib/rhcp/command_param.rb
+- lib/rhcp/response.rb
+- lib/rhcp/dispatching_broker.rb
+- lib/rhcp/broker.rb
+- lib/rhcp/http_exporter.rb
+- lib/rhcp/request.rb
+- lib/rhcp/rhcp_exception.rb
+- lib/rhcp.rb
+- test/rhcp
+- test/rhcp/client
+- test/rhcp/client/command_param_stub_test.rb
+- test/rhcp/client/command_stub_test.rb
+- test/rhcp/command_param_test.rb
+- test/rhcp/command_test.rb
+- test/rhcp/response_test.rb
+- test/rhcp/dispatching_broker_test.rb
+- test/rhcp/broker_test.rb
+- test/rhcp/http_test_server.rb
+- test/rhcp/http_exporter_test.rb
+- test/rhcp/http_registry_test.rb
+- test/rhcp/request_test.rb
+test_files: 
+- test/rhcp/client/command_param_stub_test.rb
+- test/rhcp/client/command_stub_test.rb
+- test/rhcp/command_param_test.rb
+- test/rhcp/command_test.rb
+- test/rhcp/response_test.rb
+- test/rhcp/dispatching_broker_test.rb
+- test/rhcp/broker_test.rb
+- test/rhcp/http_test_server.rb
+- test/rhcp/http_exporter_test.rb
+- test/rhcp/http_registry_test.rb
+- test/rhcp/request_test.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+