chain-reactor 0.2.0

data/test/test_chainfile_parser.rb

@@ -0,0 +1,67 @@
+require 'test/unit'
+require 'rubygems'
+require 'chainfile_parser'
+require 'helpers'
+require 'conf'
+
+# Test case for the <tt>ChainReactor::ChainfileParser</tt> class.
+class TestChainfileParser < Test::Unit::TestCase
+  include ChainReactor::TestHelpers
+
+  def test_single_reaction_is_added_to_reactor
+    chain = <<-chain
+    react_to('192.168.0.1') { |data| puts data.inspect }
+    chain
+
+    parser = ChainReactor::ChainfileParser.new(File.new(chain),
+                                               ChainReactor::Conf.new({}),
+                                               get_logger)
+    reactor = parser.parse
+    assert_equal 1, reactor.reactions_for('192.168.0.1').length
+  end
+
+  def test_multiple_reactions_are_added_to_reactor
+    chain = <<-chain
+    react_to('192.168.0.1') { |data| puts data.inspect }
+    react_to('192.168.0.2') { |data| puts data.inspect }
+    react_to('192.168.0.2') { |data| puts data.inspect }
+    chain
+
+    parser = ChainReactor::ChainfileParser.new(File.new(chain),
+                                               ChainReactor::Conf.new({}),
+                                               get_logger)
+    reactor = parser.parse
+    assert_equal 1, reactor.reactions_for('192.168.0.1').length
+    assert_equal 2, reactor.reactions_for('192.168.0.2').length
+  end
+
+  def test_multiple_reactions_are_added_to_reactor_with_alt_syntax
+    chain = <<-chain
+    react_to(['192.168.0.1','192.168.0.2']) { |data| puts data.inspect }
+    chain
+
+    parser = ChainReactor::ChainfileParser.new(File.new(chain),
+                                               ChainReactor::Conf.new({}),
+                                               get_logger)
+    reactor = parser.parse
+    assert_equal 1, reactor.reactions_for('192.168.0.1').length
+    assert_equal 1, reactor.reactions_for('192.168.0.2').length
+  end
+
+  def test_single_reaction_with_options_is_added_to_reactor
+    chain = <<-chain
+    react_to('192.168.0.1', parser: :dummy, required_keys: [:hello,:world]) { |data| puts data.inspect }
+    chain
+
+    parser = ChainReactor::ChainfileParser.new(File.new(chain),
+                                               ChainReactor::Conf.new({}),
+                                               get_logger)
+    reactor = parser.parse
+    reactions = reactor.reactions_for('192.168.0.1')
+    reaction = reactions.first
+
+    assert_equal 1, reactions.length
+    assert_equal :dummy, reaction.options[:parser]
+    assert_equal [:hello,:world], reaction.options[:required_keys]
+  end
+end

data/test/test_client_connection.rb

@@ -0,0 +1,57 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha/setup'
+require 'client_connection'
+require 'helpers'
+
+# Test case for the <tt>ChainReactor::ClientConnection</tt> class.
+class TestClientConnection < Test::Unit::TestCase
+  include ChainReactor::TestHelpers
+
+  # Create a mock TCPSocket object loaded with the data specified.
+  def mock_socket(ip,port)
+    addr = ["",port,ip.split('.')]
+    sock = stub("client socket")
+    peername = stub("peer name")
+    sock.stubs(:getpeername).returns(peername)
+    peername.stubs(:unpack).returns(addr)
+    sock
+  end
+
+  # Test that the client IP address is readable.
+  def test_ip_exists
+    ip = "127.0.0.1"
+    client = ChainReactor::ClientConnection.new(mock_socket(ip,""),get_logger)
+    assert_equal ip, client.ip
+  end
+
+  # Test that the port number is readable.
+  def test_port_exists
+    port = 20000
+    client = ChainReactor::ClientConnection.new(mock_socket("",port),get_logger)
+    assert_equal port, client.port
+  end
+  #
+  # Test that the say method uses the puts method on the socket.
+  def test_say_uses_socket_puts
+    my_string = "This is a string"
+
+    # Create mock socket that checks for method calls
+    socket = mock_socket("","")
+    socket.expects(:puts).once.with(my_string)
+
+    client = ChainReactor::ClientConnection.new(socket,get_logger)
+    client.say(my_string)
+  end
+
+  # Test that the close method uses the close method on the socket.
+  def test_close_uses_socket_close
+    # Create mock socket that checks for method calls
+    socket = mock_socket("","")
+    socket.expects(:close).once
+
+    client = ChainReactor::ClientConnection.new(socket,get_logger)
+    client.close
+  end
+
+end

data/test/test_conf.rb

@@ -0,0 +1,90 @@
+require 'test/unit'
+require 'rubygems'
+require 'conf'
+require 'helpers'
+
+# Test case for the <tt>ChainReaction::Conf</tt> class.
+class TestConf < Test::Unit::TestCase
+  include ChainReactor::TestHelpers
+  def get_conf(cli_params)
+    ChainReactor::Conf.new(cli_params)
+  end
+
+  def test_address_from_cli_params
+    params = ChainReactor::TestHelpers::Params.new({:address => CliParam.new('192.168.0.1')})
+    conf = get_conf params
+    assert_equal '192.168.0.1', conf.address
+  end
+
+  def test_address_default
+    param = CliParam.new('192.168.0.1')
+    param.given = false
+    params = Params.new({:address => param})
+    conf = get_conf params
+    conf.address = '127.0.0.1'
+    assert_equal '127.0.0.1', conf.address
+  end
+
+  def test_address_from_default_cli_params
+    param = CliParam.new('192.168.0.1')
+    param.given = false
+    params = Params.new({:address => param})
+    conf = get_conf params
+    assert_equal '192.168.0.1', conf.address
+  end
+
+  def test_address_raises_error
+    conf = ChainReactor::Conf.new(Params.new({}))
+    assert_raises(ChainReactor::ConfError) { conf.address }
+  end
+
+  def test_port
+    params = Params.new({:port => CliParam.new(20000)})
+    conf = get_conf params
+    assert_equal 20000, conf.port
+  end
+
+  def test_pid_file
+    pid_file = '/path/to/pid.file'
+    params = Params.new({:pidfile => CliParam.new(pid_file)})
+    conf = get_conf params
+    assert_equal pid_file, conf.pid_file
+  end
+
+  def test_log_file
+    log_file = '/path/to/log.file'
+    params = Params.new({:logfile => CliParam.new(log_file)})
+    conf = get_conf params
+    assert_equal log_file, conf.log_file
+  end
+
+  def test_multithreaded
+    params = Params.new({:multithreaded => CliParam.new(true)})
+    conf = get_conf params
+    assert_equal true, conf.multithreaded
+  end
+
+  def test_multithreaded_alias
+    params = Params.new({:multithreaded => CliParam.new(true)})
+    conf = get_conf params
+    assert_equal true, conf.multithreaded?
+  end
+
+  def test_verbosity
+    params = Params.new({:verbosity => CliParam.new('debug')})
+    conf = get_conf params
+    assert_equal 'debug', conf.verbosity
+  end
+
+  def test_on_top
+    params = Params.new({:ontop => CliParam.new(true)})
+    conf = get_conf params
+    assert_equal true, conf.on_top
+  end
+
+  def test_on_top_alias
+    params = Params.new({:ontop => CliParam.new(true)})
+    conf = get_conf params
+    assert_equal true, conf.on_top?
+  end
+end

data/test/test_json_parser.rb

@@ -0,0 +1,55 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha/setup'
+require 'parsers/parser'
+require 'parsers/json_parser'
+require 'helpers'
+
+# Test case for the <tt>ChainReactor::Parsers::JsonParser</tt> class.
+class TestJsonParser < Test::Unit::TestCase
+  include ChainReactor::TestHelpers
+
+  # Test that a ParseError is raised when an invalid JSON string is
+  # passed.
+  def test_parse_invalid_json_raises_error
+    parser = ChainReactor::Parsers::JsonParser.new get_logger
+    ex = assert_raise ChainReactor::Parsers::ParseError do
+      parser.parse("not a json",[],false)
+    end
+    assert_match( /not a valid JSON/, ex.message)
+  end
+
+  # Test that a ParseError is raised when a JSON with invalid keys is
+  # passed.
+  def test_parse_wrong_json_raises_error
+    parser = ChainReactor::Parsers::JsonParser.new get_logger
+    ex = assert_raise ChainReactor::Parsers::RequiredKeyError do
+      parser.parse('{"key1":"value","key2":"value"}',['monkey'],false)
+    end
+    assert_match(/Required key 'monkey'/, ex.message)
+  end
+
+  # Test that a valid JSON string returns a cause object with correct
+  # data.
+  def test_parse_valid_json_returns_hash
+    name = "A name"
+    type = "A type"
+    json = "{\"name\":\"#{name}\",\"type\":\"#{type}\"}"
+    parser = ChainReactor::Parsers::JsonParser.new get_logger
+    cause = parser.parse(json,[],false)
+    assert_equal name, cause['name']
+    assert_equal type, cause['type']
+  end
+
+  # Test that a valid JSON string returns a cause object with correct
+  # data.
+  def test_parse_valid_json_returns_hash_with_symbol_keys
+    name = "A name"
+    type = "A type"
+    json = "{\"name\":\"#{name}\",\"type\":\"#{type}\"}"
+    parser = ChainReactor::Parsers::JsonParser.new get_logger
+    cause = parser.parse(json,[],true)
+    assert_equal name, cause[:name]
+    assert_equal type, cause[:type]
+  end
+end

data/test/test_parser_factory.rb

@@ -0,0 +1,30 @@
+require 'test/unit'
+require 'rubygems'
+require 'parser_factory'
+require 'helpers'
+require 'dummy_parser'
+
+# Test case for the <tt>ChainReactor::ParserFactory</tt> class.
+class TestParserFactory < Test::Unit::TestCase
+  include ChainReactor::TestHelpers
+
+  def test_get_parser_gives_json_parser_with_symbol
+    parser = ChainReactor::ParserFactory.get_parser(:json,get_logger)
+    assert_kind_of ChainReactor::Parsers::JsonParser, parser
+  end
+
+  def test_get_parser_gives_dummy_parser_with_symbol
+    parser = ChainReactor::ParserFactory.get_parser(:dummy,get_logger)
+    assert_kind_of ChainReactor::Parsers::DummyParser, parser
+  end
+
+  def test_get_parser_gives_dummy_parser_with_string
+    parser = ChainReactor::ParserFactory.get_parser('dummy',get_logger)
+    assert_kind_of ChainReactor::Parsers::DummyParser, parser
+  end
+  
+  def test_get_parser_gives_dummy_parser_with_capitalized_string
+    parser = ChainReactor::ParserFactory.get_parser('Dummy',get_logger)
+    assert_kind_of ChainReactor::Parsers::DummyParser, parser
+  end
+end

data/test/test_reaction.rb

@@ -0,0 +1,39 @@
+require 'test/unit'
+require 'rubygems'
+require 'reactor'
+require 'helpers'
+require 'dummy_parser'
+
+
+# Test case for the <tt>ChainReactor::Reaction</tt> class.
+class TestReaction < Test::Unit::TestCase
+  include ChainReactor::TestHelpers
+  
+  def test_block_is_executed
+    block = Proc.new { |d| raise 'Block has been called' }
+    reaction = ChainReactor::Reaction.new({:parser => :dummy}, block, get_logger)
+
+    assert_raise ChainReactor::ReactionError, 'Block has been called' do
+      reaction.execute('')
+    end
+  end
+
+  def test_execute_sets_previous_result
+    block = Proc.new { |d| 'Block has been called' }
+    reaction = ChainReactor::Reaction.new({:parser => :dummy}, block, get_logger)
+    reaction.execute('')
+
+    assert_equal 'Block has been called', reaction.previous_result
+  end
+  
+  def test_execute_sets_previous_data
+    
+    block = Proc.new { |d| 'Block has been called' }
+    reaction = ChainReactor::Reaction.new({:parser => :json}, block, get_logger)
+    data_string = '{"hello" : "world"}'
+    data = {:hello => 'world'}
+    reaction.execute(data_string)
+
+    assert_equal data, reaction.previous_data
+  end
+end

data/test/test_reactor.rb

@@ -0,0 +1,63 @@
+require 'test/unit'
+require 'rubygems'
+require 'reactor'
+require 'helpers'
+require 'dummy_parser'
+
+# Test case for the <tt>ChainReaction::Reaction</tt> class.
+class TestReactor < Test::Unit::TestCase
+  include ChainReactor::TestHelpers
+  
+  def test_address_not_allowed_by_default
+    reactor = ChainReactor::Reactor.new get_logger
+    assert_equal false, reactor.address_allowed?('192.168.0.1')
+  end
+  
+  def test_adding_reaction_makes_address_allowable
+    reactor = ChainReactor::Reactor.new get_logger
+    reactor.add(['127.0.0.1'],{parser: :dummy},Proc.new {})
+    assert reactor.address_allowed? '127.0.0.1'
+  end
+
+  def test_react_raises_error
+    reactor = ChainReactor::Reactor.new get_logger
+    assert_raises RuntimeError, 'Address is not allowed' do
+      reactor.react('127.0.0.1',{parser: :dummy})
+    end
+  end
+
+  def test_react_calls_block
+    reactor = ChainReactor::Reactor.new get_logger
+    block = Proc.new { |d| 'block has been called' }
+    reactor.add(['127.0.0.1'],{parser: :dummy},block)
+    reactions = reactor.reactions_for('127.0.0.1')
+    reactor.react('127.0.0.1','This is a string')
+    assert_equal 'block has been called', reactions[0].previous_result
+  end
+
+  def test_react_calls_multiple_blocks
+    reactor = ChainReactor::Reactor.new get_logger
+
+    block1 = Proc.new { |d| 'block1' }
+    block2 = Proc.new { |d| 'block2' }
+
+    reactor.add(['127.0.0.1'],{parser: :dummy},block1)
+    reactor.add(['127.0.0.1'],{parser: :dummy},block2)
+
+    reactor.react('127.0.0.1','This is a string')
+
+    reactions = reactor.reactions_for('127.0.0.1')
+    assert_equal 'block1', reactions[0].previous_result
+    assert_equal 'block2', reactions[1].previous_result
+  end
+
+  def test_react_catches_exceptions
+    reactor = ChainReactor::Reactor.new get_logger
+    block = Proc.new { |d| raise 'Block has been called' }
+    reactor.add(['127.0.0.1'],{parser: :dummy},block)
+    reactor.reactions_for('127.0.0.1')
+    assert_nothing_raised do
+      reactor.react('127.0.0.1','This is a string')
+    end
+  end
+end

data/test/test_xml_simple_parser.rb

@@ -0,0 +1,65 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha/setup'
+require 'parsers/parser'
+require 'parsers/xml_simple_parser'
+require 'helpers'
+
+# Test case for the <tt>ChainReactor::Parsers::XmlSimpleParser</tt> class.
+class TestXmlSimpleParser < Test::Unit::TestCase
+  include ChainReactor::TestHelpers
+
+  # Test that a ParseError is raised when an invalid xml string is
+  # passed.
+  def test_parse_non_xml_raises_error
+    parser = ChainReactor::Parsers::XmlSimpleParser.new get_logger
+    ex = assert_raise ChainReactor::Parsers::ParseError do
+      parser.parse("not an xml string",[],false)
+    end
+    assert_match( /not a valid XML string/, ex.message)
+  end
+  
+  # Test that a ParseError is raised when an invalid xml string is
+  # passed.
+  def test_parse_invalid_xml_raises_error
+    parser = ChainReactor::Parsers::XmlSimpleParser.new get_logger
+    ex = assert_raise ChainReactor::Parsers::ParseError do
+      parser.parse("<data>",[],false)
+    end
+    assert_match( /not a valid XML string/, ex.message)
+  end
+
+  # Test that a ParseError is raised when a xml with invalid keys is
+  # passed.
+  def test_parse_wrong_xml_raises_error
+    parser = ChainReactor::Parsers::XmlSimpleParser.new get_logger
+    ex = assert_raise ChainReactor::Parsers::RequiredKeyError do
+      parser.parse('<data><key1>value</key1><key2>value</key2></data>',['monkey'],false)
+    end
+    assert_match(/Required key 'monkey'/, ex.message)
+  end
+
+  # Test that a valid xml string returns a cause object with correct
+  # data.
+  def test_parse_valid_xml_returns_hash
+    name = "A name"
+    type = "A type"
+    xml = "<data><name>#{name}</name><type>#{type}</type></data>"
+    parser = ChainReactor::Parsers::XmlSimpleParser.new get_logger
+    cause = parser.parse(xml,[],false)
+    assert_equal name, cause['name'].first
+    assert_equal type, cause['type'].first
+  end
+
+  # Test that a valid xml string returns a cause object with correct
+  # data.
+  def test_parse_valid_xml_returns_hash_with_symbol_keys
+    name = "A name"
+    type = "A type"
+    xml = "<data><name>#{name}</name><type>#{type}</type></data>"
+    parser = ChainReactor::Parsers::XmlSimpleParser.new get_logger
+    cause = parser.parse(xml,[],true)
+    assert_equal name, cause[:name].first
+    assert_equal type, cause[:type].first
+  end
+end