rhcp 0.1.2 → 0.1.3

data/lib/rhcp/response.rb

@@ -1,62 +0,0 @@
-require 'rubygems'
-require 'json'
-
-module RHCP
-
-  class Response
-
-    class Status
-      OK="ok"
-      ERROR="error"
-    end
-
-    # TODO these should be attr_reader's, but then we've got to solve json_create() differently
-    attr_accessor :status
-    attr_accessor :error_text
-    attr_accessor :error_detail
-    attr_accessor :data
-    
-    # textual description of the result (optional)
-    attr_accessor :result_text
-
-    def initialize
-      @status = Status::OK
-      @error_text = ""
-      @error_detail = ""
-      @result_text = "";
-    end
-    
-    def mark_as_error(text, detail="")
-      @status = Status::ERROR
-      @error_text = text
-      @error_detail = detail
-    end
-
-    def set_payload(data)
-      @data = data
-    end
-    
-    def self.reconstruct_from_json(json_data)
-      object = JSON.parse(json_data)
-      instance = self.new()
-      instance.status = object["status"]
-      instance.error_text = object["error_text"]
-      instance.error_detail = object["error_detail"]
-      instance.set_payload(object["data"])
-      instance.result_text = object['result_text']
-      instance
-    end
-    
-    def to_json(*args)
-      {
-        'status' => @status,
-        'error_text' => @error_text,
-        'error_detail' => @error_detail,
-        'data' => @data,   # TODO what about JSONinification of data? (probably data should be JSON-ish data only, i.e. no special objects)
-        'result_text' => @result_text
-      }.to_json(*args)
-    end    
-
-  end
-
-end

data/lib/rhcp/rhcp_exception.rb

@@ -1,6 +0,0 @@
-module RHCP
-  
-  class RhcpException < Exception
-  end
-  
-end

data/test/rhcp/broker_test.rb

@@ -1,29 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
-
-require 'test/unit'
-
-require 'rhcp'
-
-class BrokerTest < Test::Unit::TestCase
-
-  def test_register_commands
-    broker = RHCP::Broker.new()
-    assert_not_nil broker
-    commands = broker.get_command_list
-    assert_not_nil commands
-    assert_equal 0, commands.size
-    
-    command = RHCP::Command.new("test", "a test command", lambda {})
-    broker.register_command(command)
-    commands = broker.get_command_list
-    assert_equal 1, commands.size
-    assert_equal command, commands["test"]
-  end
-  
-  def test_register_duplicate
-    broker = RHCP::Broker.new()
-    broker.register_command RHCP::Command.new("test", "a test command", lambda {})
-    assert_raise(RHCP::RhcpException) { broker.register_command RHCP::Command.new("test", "a command with the same name", lambda {}) }
-  end
-  
-end

data/test/rhcp/client/command_param_stub_test.rb

@@ -1,73 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
-
-require 'test/unit'
-require 'rhcp/client/command_param_stub'
-require 'rhcp/command_param'
-
-class CommandParamStubTest < Test::Unit::TestCase
-
-  def param_lookup
-    ["foo", "bar", "baz"]
-  end
-  
-  def setup
-    @p = 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
-    )    
-  end
-  
-  def test_json
-    json = @p.to_json
-    puts "json : >>#{json}<<"
-    p2 = RHCP::Client::CommandParamStub.reconstruct_from_json(json)
-    assert_not_nil p2
-    assert_instance_of RHCP::Client::CommandParamStub, p2
-    assert_equal @p.name, p2.name
-    assert_equal @p.description, p2.description
-    assert_equal @p.allows_multiple_values, p2.allows_multiple_values
-    assert_equal @p.has_lookup_values, p2.has_lookup_values
-    assert_equal @p.is_default_param, p2.is_default_param
-    assert_equal @p.mandatory, p2.mandatory
-    
-    json_hash = JSON.parse(json)
-    p3 = RHCP::Client::CommandParamStub.reconstruct_from_json(json_hash)
-    assert_instance_of RHCP::Client::CommandParamStub, p3
-    assert_equal @p.name, p3.name
-    assert_equal @p.description, p3.description
-    assert_equal @p.allows_multiple_values, p3.allows_multiple_values
-  end
-  
-  # when a param is "stubbed", it should be possible to inject a method
-  # for retrieving the lookup values
-  def test_stubbing
-    json = @p.to_json
-    stub = RHCP::Client::CommandParamStub.reconstruct_from_json(json)
-    stub.get_lookup_values_block = lambda {
-      |partial_value|
-      [ "mascarpone", "limoncello" ]
-    }
-    lookup_values = stub.get_lookup_values()
-    assert_equal [ "mascarpone", "limoncello" ], lookup_values
-  end
-  
-  def test_stubbing_without_lookup_values
-    p = RHCP::CommandParam.new("test", "without lookup values",
-      :mandatory => true,
-      :allows_multiple_values => true,
-      :is_default_param => true
-    )
-    stub = RHCP::Client::CommandParamStub.reconstruct_from_json(p.to_json())
-    has_been_invoked = false
-    stub.get_lookup_values_block = lambda {
-      |partial_value|
-      has_been_invoked = true
-    }
-    stub.get_lookup_values()
-    assert_equal false, has_been_invoked
-  end
-  
-  
-end

data/test/rhcp/client/command_stub_test.rb

@@ -1,40 +0,0 @@
-$:.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"))
-    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
-    
-    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
-  
-end

data/test/rhcp/command_param_test.rb

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

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

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