rhcp 0.1.2 → 0.1.3

data/test/rhcp/http_exporter_test.rb

@@ -1,113 +0,0 @@
-$:.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

@@ -1,73 +0,0 @@
-# 
-# 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

@@ -1,47 +0,0 @@
-$:.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

@@ -1,124 +0,0 @@
-$:.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

@@ -1,45 +0,0 @@
-# 
-# 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