rhcp 0.1.9 → 0.2.14

data/lib/rhcp/request.rb

@@ -6,41 +6,53 @@ require 'json'
 
 module RHCP
 
-  # This class represents a request made by a RHCP client to a RHCP server.
+  # This class represents a request initiated by a RHCP client to a RHCP server.
   # It is passed as an argument to the method that should execute the requested
   # command
   class Request
-    
+
     attr_reader :command
     attr_reader :param_values
+    attr_reader :context
 
     # default constructor; will throw exceptions on invalid values
-    def initialize(command, param_values = {})    
+    def initialize(command, some_param_values = {}, context = RHCP::Context.new())
+      param_values = some_param_values.clone()
+      @logger = RHCP::ModuleHelper.instance().logger
       raise RHCP::RhcpException.new("command may not be null") if command == nil
-      
+      @logger.debug "initializing request #{command.name} with params #{param_values}"
+
+      @context = context
+
+      command.params.each do |param|
+        value_from_context = param.find_value_in_context(context)
+        if value_from_context != nil          
+          # if the parameter has been specified in the param values, do not override
+          if ! param_values.has_key?(param.name)
+            @logger.debug "pre-filling param #{param.name} with value '#{value_from_context}' (context key '#{param.autofill_context_key}')"
+            param_values[param.name] = value_from_context
+          end
+        end
+      end
+
       # autobox the parameters if necessary
       param_values.each do |k,v|
         if ! v.instance_of?(Array)
           param_values[k] = [ v ]
         end
       end
-      
-      # check all param values for plausibility
-      param_values.each do |key,value|
-        command.get_param(key).check_param_is_valid(value)
-      end
-      
-      # check that we've got all mandatory params
-      command.params.each do |name, param|
-        raise RHCP::RhcpException.new("missing mandatory parameter '#{name}'") if param.mandatory && ! param_values.has_key?(name)
-      end
-      
+
       @command = command
       @param_values = param_values
+
+      printable_param_values = param_values.map do |a,b|
+        a + '=' + b.join(',')
+      end.join('; ')
+      @logger.debug("request initialized : command '#{command.name}', params : #{printable_param_values}")
     end
 
     # used to retrieve the value for the specified parameter
-    # returns either the value or an array of values if the parameter allows 
+    # returns either the value or an array of values if the parameter allows
     # multiple values
     def get_param_value(param_name)
       raise "no such parameter : #{param_name}" unless @param_values.has_key?(param_name)
@@ -55,13 +67,13 @@ module RHCP
     def has_param_value(param_name)
       @param_values.has_key?(param_name)
     end
-    
+
     # convenience method that executes the command that actually delegates to the
     # command that's inside this request
     def execute
       @command.execute_request(self)
     end
-    
+
     # reconstructs the request from it's JSON representation
     # Since the JSON version of a request does hold the command name instead
     # of the full command only, a broker is needed to lookup the command by
@@ -72,18 +84,25 @@ module RHCP
     #   +json_data+ is the JSON data that represents the request
     def self.reconstruct_from_json(broker, json_data)
       object = JSON.parse(json_data)
-      command = broker.get_command(object['command_name'])
-      self.new(command, object['param_values'])
+      
+      context = object.has_key?('context') ?
+        RHCP::Context.reconstruct_from_json(object['context']) :
+        RHCP::Context.new(object['cookies'])
+        
+      command = broker.get_command(object['command_name'], context)      
+        
+      self.new(command, object['param_values'], context)
     end
-    
+
     # returns a JSON representation of this request.
     def to_json(*args)
       {
         'command_name' => @command.name,
-        'param_values' => @param_values
+        'param_values' => @param_values,
+        'context' => @context.to_json
       }.to_json(*args)
-    end    
-    
+    end
+
     def to_s
       "#{@command.name} (#{@param_values})"
     end

data/lib/rhcp/response.rb

@@ -15,15 +15,20 @@ module RHCP
     attr_accessor :error_text
     attr_accessor :error_detail
     attr_accessor :data
+    # TODO this should be called 'cookies'
+    attr_accessor :context
     
     # textual description of the result (optional)
     attr_accessor :result_text
+    attr_accessor :created_at
 
     def initialize
       @status = Status::OK
       @error_text = ""
       @error_detail = ""
-      @result_text = "";
+      @result_text = ""
+      @context = nil
+      @created_at = Time.now().to_i
     end
     
     def mark_as_error(text, detail="")
@@ -35,6 +40,10 @@ module RHCP
     def set_payload(data)
       @data = data
     end
+
+    def set_context(new_context)
+      @context = new_context
+    end
     
     def self.reconstruct_from_json(json_data)
       object = JSON.parse(json_data)
@@ -44,6 +53,8 @@ module RHCP
       instance.error_detail = object["error_detail"]
       instance.set_payload(object["data"])
       instance.result_text = object['result_text']
+      instance.context = object['cookies']
+      instance.created_at = object['created_at']
       instance
     end
     
@@ -53,10 +64,12 @@ module RHCP
         '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
+        'result_text' => @result_text,
+        'cookies' => @context,
+        'created_at' => @created_at
       }.to_json(*args)
     end    
 
   end
 
-end
+end

data/test/rhcp/broker_test.rb

@@ -1,29 +1,19 @@
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+$:.unshift File.join(File.dirname(__FILE__),'..','..','lib')
 
 require 'test/unit'
 
 require 'rhcp'
+require 'rhcp/tests_for_brokers'
+require 'rhcp/tests_for_writable_brokers'
 
 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 {}) }
+  include TestsForBrokers
+  include TestsForWritableBrokers
+
+  def setup
+    @broker = RHCP::Broker.new()
+    @test_broker = @broker
   end
-  
+
 end

data/test/rhcp/client/command_param_stub_test.rb

@@ -1,10 +1,12 @@
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+$:.unshift File.join(File.dirname(__FILE__),'..','..', '..', 'lib')
 
 require 'test/unit'
+require 'rhcp/test_base'
 require 'rhcp/client/command_param_stub'
+require 'rhcp'
 require 'rhcp/command_param'
 
-class CommandParamStubTest < Test::Unit::TestCase
+class CommandParamStubTest < TestBase
 
   def param_lookup
     ["foo", "bar", "baz"]
@@ -15,7 +17,8 @@ class CommandParamStubTest < Test::Unit::TestCase
       :mandatory => true,
       :allows_multiple_values => true,
       :lookup_method => self.method(:param_lookup),
-      :is_default_param => true
+      :is_default_param => true,
+      :autofill_context_key => 'zaphod'
     )    
   end
   
@@ -31,6 +34,7 @@ class CommandParamStubTest < Test::Unit::TestCase
     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
+    assert_equal @p.autofill_context_key, p2.autofill_context_key
     
     json_hash = JSON.parse(json)
     p3 = RHCP::Client::CommandParamStub.reconstruct_from_json(json_hash)
@@ -49,7 +53,13 @@ class CommandParamStubTest < Test::Unit::TestCase
       |partial_value|
       [ "mascarpone", "limoncello" ]
     }
-    lookup_values = stub.get_lookup_values()
+    command = RHCP::Command.new("test", "a command for testing", lambda { |request,response|
+      first_param = request.get_param_value("first_param")
+      puts "just testing : #{first_param}"
+      first_param.reverse
+    })
+    request = RHCP::Request.new(command, {})
+    lookup_values = stub.get_lookup_values(request)
     assert_equal [ "mascarpone", "limoncello" ], lookup_values
   end
   
@@ -65,7 +75,7 @@ class CommandParamStubTest < Test::Unit::TestCase
       |partial_value|
       has_been_invoked = true
     }
-    stub.get_lookup_values()
+    stub.get_lookup_values(nil, nil)
     assert_equal false, has_been_invoked
   end
   

data/test/rhcp/client/command_stub_test.rb

@@ -1,4 +1,4 @@
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+$:.unshift File.join(File.dirname(__FILE__),'..','..','..','lib')
 
 require 'rubygems'
 require 'json'

data/test/rhcp/command_param_test.rb

@@ -1,4 +1,4 @@
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+$:.unshift File.join(File.dirname(__FILE__),'..','..','lib')
 
 require 'test/unit'
 require 'rhcp/command_param'
@@ -32,41 +32,26 @@ class CommandParamTest < Test::Unit::TestCase
     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
+#  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(nil, nil)
+#  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
   
 end

data/test/rhcp/command_test.rb

@@ -1,4 +1,4 @@
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+$:.unshift File.join(File.dirname(__FILE__),'..','..','lib')
 
 require 'test/unit'
 require 'rhcp'
@@ -20,8 +20,9 @@ class CommandTest < Test::Unit::TestCase
     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_instance_of Array, command.params
     assert_equal 0, command.params.size
     
     command.add_param(RHCP::CommandParam.new("first_param", "this is the first param"))
@@ -132,5 +133,62 @@ class CommandTest < Test::Unit::TestCase
     assert ! @listener2_fired
   end
 
+  def test_enabled_through_context
+    command = RHCP::Command.new("context_test", "testing the context", 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"
+    })
+
+    # by default, commands should be enabled even with an empty context
+    assert command.is_enabled?
+    assert command.is_enabled?({})
+
+    # if we pass an empty list of context_keys, the command should be disabled
+    command.enabled_through_context_keys = []
+    assert ! command.is_enabled?
+
+    context = RHCP::Context.new()
+    context.cookies['ankh'] = 'morpork'
+    
+    command.enabled_through_context_keys = ['host']
+    assert ! command.is_enabled?
+    assert ! command.is_enabled?(context)
+    context.cookies['host'] = 'deepthought'
+    assert command.is_enabled?(context)
+  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_raise(RHCP::RhcpException) {
+      request = RHCP::Request.new(command, {
+          "does_not_exist" =>  [ "single value for non-existing param" ]
+      })
+      command.execute_request(request)
+    }
+  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"))
+    request = RHCP::Request.new(command, {
+          "real_param" =>  [ "value for the real param", "another value for the real param" ]
+    })
+    assert_raise(RHCP::RhcpException) { command.execute_request(request) }
+  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 }))
+
+    assert_raise(RHCP::RhcpException) {
+      request = RHCP::Request.new(command, {})
+      command.execute_request(request)
+    }
+  end
+
 end
 

data/test/rhcp/context_aware_broker_test.rb

@@ -0,0 +1,86 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','..','lib')
+
+require 'test/unit'
+require 'rhcp'
+
+require 'test/unit'
+require 'rhcp/tests_for_brokers'
+
+class ContextAwareBrokerTest < Test::Unit::TestCase
+
+  include TestsForBrokers
+
+  def setup
+    broker = RHCP::Broker.new()
+    
+    @broker = broker
+    @test_broker = RHCP::Client::ContextAwareBroker.new(broker)
+  end
+
+  def add_context_commands
+    @switch_host = RHCP::Command.new("switch_host", "modifies the context",
+      lambda { |request, response|
+        response.set_context({'host' => request.get_param_value('new_host')})
+      }
+    )
+    @switch_host.add_param(RHCP::CommandParam.new("new_host", "the new host name",
+        {
+          :mandatory => true,
+          :is_default_param => true,
+        }
+    ))
+    @broker.register_command @switch_host
+
+    @host_command = RHCP::Command.new("say_hello", "uses context",
+      lambda { |request, response|
+        "hello from " + request.get_param_value('the_host')
+      }
+    )
+    @host_command.add_param(RHCP::CommandParam.new("the_host", "the host name (should be taken from context)",
+        {
+          :mandatory => true,
+          :is_default_param => true,
+          :autofill_context_key => 'host'
+        }
+    ))
+    @broker.register_command @host_command
+
+    context_command = RHCP::Command.new("let_explode_host", "available only in host context",
+      lambda { |request, response|
+        "kaboom."
+      }
+    )
+    context_command.enabled_through_context_keys = ['host']
+    @broker.register_command context_command
+  end
+
+  def test_context_aware_command_list
+    add_context_commands
+
+    assert_equal 2, @test_broker.get_command_list().size
+    @test_broker.context.cookies['host'] = 'moriturus'
+    assert_equal 3, @test_broker.get_command_list().size
+  end
+
+  def test_context_setting_command
+    add_context_commands
+
+    request = RHCP::Request.new(@switch_host, {'new_host' => 'lucky bastard'})
+    @test_broker.execute(request)
+    assert_equal 'lucky bastard', @test_broker.context.cookies['host']
+    request = RHCP::Request.new(@host_command, {})
+    assert_equal "hello from lucky bastard", @test_broker.execute(request).data
+  end
+
+  def test_invoke_twice
+    add_context_commands
+
+    @test_broker.context.cookies['host'] = 'the_host'
+    request = RHCP::Request.new(@host_command)
+    response = @test_broker.execute(request)
+    assert_equal "hello from the_host", response.data
+
+    response = @test_broker.execute(request)
+    assert_equal "hello from the_host", response.data
+  end
+end