rhcp 0.1.3 → 0.1.4

data/test/rhcp/client/command_stub_test.rb

@@ -0,0 +1,56 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'rubygems'
+require 'json'
+
+require 'test/unit'
+require 'rhcp'
+require 'rhcp'
+require 'rhcp'
+
+class CommandStubTest < 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 test_json
+    c = RHCP::Command.new("test", "a command for testing", self.method(:command_method))
+    c.add_param(RHCP::CommandParam.new("first_param", "this is the first param"))
+    c.result_hints[:display_type] = "table"
+    json = c.to_json
+    puts "JSON : >>#{JSON.pretty_generate(c)}<<"
+    assert_not_nil json
+    c2 = RHCP::Client::CommandStub.reconstruct_from_json(json)
+    assert_not_nil c2
+    assert_instance_of RHCP::Client::CommandStub, c2
+    assert_equal c.name, c2.name
+    assert_equal c.description, c2.description
+    assert_equal c.params.size, c2.params.size
+    assert_equal c.result_hints, c2.result_hints
+    
+    json_hash = JSON.parse(json)
+    c3 = RHCP::Client::CommandStub.reconstruct_from_json(json_hash)
+    assert_instance_of RHCP::Client::CommandStub, c3
+    assert_equal c.name, c3.name
+    assert_equal c.description, c3.description
+    assert_equal c.params.size, c3.params.size
+  end
+  
+  def test_json_without_result_hints
+    c = RHCP::Command.new("test", "no hints this time", lambda {})
+    json = c.to_json
+    puts "JSON : >>#{JSON.pretty_generate(c)}<<"
+    assert_not_nil json
+    c2 = RHCP::Client::CommandStub.reconstruct_from_json(json)
+    assert_not_nil c2
+    assert_instance_of RHCP::Client::CommandStub, c2
+    assert_equal c.name, c2.name
+    assert_equal c.description, c2.description
+    assert_equal c.params.size, c2.params.size
+    assert_equal c.result_hints, c2.result_hints
+  end
+  
+end

data/test/rhcp/command_param_test.rb

@@ -0,0 +1,72 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'rhcp/command_param'
+
+class CommandParamTest < Test::Unit::TestCase
+  
+  def param_lookup
+    ["foo", "bar", "baz"]
+  end
+  
+  def test_creation
+    param = RHCP::CommandParam.new("test", "this param is used for testing purposes only")
+    assert_not_nil param, "a param should not be nil after creation"
+    assert_equal false, param.mandatory, "by default, params should not be mandatory"
+    assert_equal false, param.has_lookup_values, "by default, a param does not have lookup values"
+    assert_equal false, param.allows_multiple_values, "by default, a param should not allow multiple values"
+    assert_equal false, param.is_default_param
+  end
+  
+  def test_options
+    param = RHCP::CommandParam.new("test", "this param is used for testing purposes only",
+      :mandatory => true,
+      :allows_multiple_values => true,
+      :lookup_method => self.method(:param_lookup),
+      :is_default_param => true
+    )
+    assert_not_nil param, "a param should not be nil after creation"
+    assert_equal true, param.mandatory
+    assert_equal true, param.allows_multiple_values
+    assert_equal true, param.has_lookup_values
+    assert_equal true, param.is_default_param
+  end
+  
+  def test_lookup_values
+    param = RHCP::CommandParam.new("lookup_test", "testing if lookup values are working",
+      :lookup_method => self.method(:param_lookup)
+    )
+    assert_not_nil param
+    assert_equal param_lookup(), param.get_lookup_values()
+  end
+  
+  def test_partial_lookup_values
+    param = RHCP::CommandParam.new("lookup_test", "testing if partial lookup values are working",
+      :lookup_method => self.method(:param_lookup)
+    )
+    assert_not_nil param
+    assert_equal ["bar", "baz"], param.get_lookup_values("ba")
+  end
+  
+  def test_get_lookup_values_without_lookup
+    param = RHCP::CommandParam.new("lookup_test", "testing if partial lookup values are working")
+    assert_not_nil param
+    assert_equal [], param.get_lookup_values()
+  end
+  
+  def test_check_param_is_valid
+    param = RHCP::CommandParam.new("validity_test", "testing if valid values are valid")
+    assert_not_nil param
+    assert param.check_param_is_valid([ "bla" ])
+    assert_raise(RHCP::RhcpException) { param.check_param_is_valid [ "bla", "blubb" ] }
+  end
+  
+  # values that aren't part of the lookup values are invalid
+  def test_check_param_is_valid_lookup_values
+    param = RHCP::CommandParam.new("lookup_test", "testing if partial lookup values are working",
+      :lookup_method => self.method(:param_lookup)
+    )
+    assert_raise(RHCP::RhcpException) { param.check_param_is_valid(["zaphod"]) }
+  end
+  
+end

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