evegem 0.1.2

data/lib/eve/messenger.rb

@@ -0,0 +1,138 @@
+module Eve
+  
+  class Messenger
+
+    attr_accessor :display, :history, :piggy_backs, :ok_filters, :nok_filters
+    
+    def initialize(data = {})
+      @display = data[:display] || :stdio
+      @piggy_backs = []
+      @ok_filters = []
+      @nok_filters = []
+      reset
+    end
+    
+    def add_filter(raw_input)
+      raw_input = "#{raw_input}"
+      if raw_input.start_with?("!")
+        @nok_filters << raw_input[1..-1]
+      else
+        @ok_filters << raw_input
+      end
+    end
+    
+    def display=(val)
+      @display = val || :stdio
+    end
+    
+    def event_machine?
+      @display.kind_of?(Hash) && !@display[:event_machine].nil?
+    end
+    
+    def event_machine
+      @display[:event_machine]
+    end
+    
+    def file?
+      @display.kind_of?(Hash) && !@display[:filename].nil?
+    end
+      
+    def overwrite_file?
+      file? && @display[:mode] == :overwrite
+    end
+      
+    def is_data_only?
+      @display.kind_of?(Hash) && @display[:mode] == "data_only"
+    end
+    
+    def reset
+      @flagged_history = {}
+      @history = []
+      @piggy_backs.each { |m| m.reset }
+    end
+    
+    def history(flag = nil)
+      return @history if flag.nil?
+      @flagged_history[flag] || []
+    end
+    
+    def has_flag?(flag)
+      return !@flagged_history[flag].nil?
+    end
+    
+    def was_printed?(msg)
+      @history.include?(msg)
+    end
+
+    [:info, :debug, :error].each do |name|
+      plural_name = "#{name}s".to_sym
+      has_message_name = "#{name}s?"
+      has_specific_message_name = "#{name}?"
+      
+      define_method name do |msg|
+        self.print(msg,{ :flag => name })
+      end
+      
+      define_method plural_name do
+        self.history(name)
+      end
+      
+      define_method has_message_name do
+        self.has_flag?(name)
+      end
+      
+      define_method has_specific_message_name do |msg|
+        return false unless self.has_flag?(name)
+        @flagged_history[name].include?(msg)
+      end
+    end
+    
+    def print(output, options = {})
+      @piggy_backs.each { |m| m.print(output,options.clone) }
+      return unless should_print?(options)
+      add_history(output,options.delete(:flag))
+      if @display == :stdio && options.empty?
+        STDOUT.print output
+      elsif @display == :stdio
+        Kernel.ap output, options
+      elsif event_machine?
+        event_machine.send_data(output)
+      elsif file?
+        system("mkdir -p #{Pathname.new(@display[:filename]).parent}")
+        open(@display[:filename], overwrite_file? ? "w" : "a+") { |f| f.puts(output) }
+      else
+        output
+      end
+    end
+    
+    private
+
+      def should_print?(options)
+        return true if @ok_filters.empty? && @nok_filters.empty?
+        all_flags = options[:flag].kind_of?(Array) ? options[:flag] : [ options[:flag] ]
+        all_flags.each do |f|
+          return true if should_print_flag?(f)
+        end
+        false
+      end
+
+      def should_print_flag?(input)
+        flag = "#{input}"
+        should_add = @ok_filters.include?(flag)
+        should_not_add = @nok_filters.include?(flag) || @nok_filters.empty?
+        should_add || !should_not_add
+      end
+
+
+      def add_history(output,flag)
+        unless flag.nil?
+          (flag.kind_of?(Array) ? flag : [flag]).each do |f|
+            @flagged_history[f] ||= []
+            @flagged_history[f] << output
+          end
+        end
+        @history <<  output
+      end
+  end
+  
+end

data/lib/eve/registry.rb

@@ -0,0 +1,35 @@
+module Eve
+  
+  class Registry
+
+    def self.handle?(cmd)
+      action, data = action_and_input(cmd)
+      available.include?(action)
+    end
+    
+    def self.handle(app,cmd,display_messages)
+      result = app.default_result
+      action, data = action_and_input(cmd)
+      inner_action, inner_data = action_and_input(data)
+      if available[action].include?(inner_action)
+        result = send(Application.methodize("call_#{action}_#{inner_action}"), app, result, inner_data, display_messages)  
+      else
+        result = send(Application.methodize("call_#{action}"), app, result, data, display_messages)  
+      end
+      result
+    end
+    
+    private
+
+      def self.action_and_input(raw)
+        return [ "", nil ] if raw.nil?
+        action = raw.split.shift
+        return [ "", nil ] if (action.nil? || action.starts_with?("#"))
+        data = raw[(action.size)..-1].strip
+        [ action, data ]
+      end
+
+        
+  end
+  
+end

data/lib/eve/version.rb

@@ -0,0 +1,3 @@
+module Eve
+  VERSION = "0.1.2" unless Eve.const_defined?("VERSION")
+end

data/lib/eve/web_server.rb

@@ -0,0 +1,22 @@
+module Eve
+  
+  class WebServer
+
+    def call(env)
+      
+      response = ""
+      Application.ids.each do |id|
+        app = Application.new(:id => id)
+        response += "<div>ID: #{app.id} (#{app.alive?})</div>"
+      end
+      
+      [
+        200, 
+        {"Content-Type" => "text/html"}, 
+        [response]
+      ]
+    end
+
+  end
+  
+end

data/lib/evegem.rb

@@ -0,0 +1,23 @@
+require 'awesome_print'
+require 'pathname'
+require 'net/ftp'
+require 'net/ssh'
+require 'net/telnet'
+require 'tempfile'
+require 'eventmachine'
+require 'utest'
+require 'watchme'
+require 'csv'
+require "redis"
+
+dir = File.dirname(__FILE__)
+require "#{dir}/eve/io"
+require "#{dir}/eve/registry"
+require "#{dir}/eve/web_server"
+require "#{dir}/eve/application"
+require "#{dir}/eve/version"
+require "#{dir}/eve/messenger"
+require "#{dir}/eve/message"
+require "#{dir}/eve/layout"
+require "#{dir}/eve/file_notifier_server"
+require "#{dir}/eve/event_server"

data/lib/registry/base_registry.rb

@@ -0,0 +1,60 @@
+module Eve
+  
+  class BaseRegistry < Registry
+
+    @@cmd_data = {
+      "export" => [],
+      "import" => [],
+      "sleep" => [],
+      "ruby" => [],
+    }
+        
+    def self.available
+      @@cmd_data
+    end
+
+    #------------
+    # CALLER METHODS
+    #------------ 
+
+    def self.call_export(app,result,filename,display_messages)
+      filename = "./eve.cmd" if filename == "" || filename.nil?
+      result[:data] = filename
+      IO.write(filename,app.cmds.join("\n"))
+      app.message.print_exported_commands(filename) if display_messages
+      result
+    end
+    
+    def self.call_import(app,result,filename,display_messages)
+      filename = "./eve.cmd" if filename == "" || filename.nil?
+      result[:data] = filename
+      result[:track_cmd] = false
+      app.message.print_importing_commands(filename) if display_messages
+      count = 0
+      IO.readlines(filename).each do |raw|
+        script = raw.strip
+        next if script == "" || script[0] == "#"
+        count += 1
+        app.cmd(script,display_messages,true)
+      end
+      app.message.print_importing_complete(filename,count) if display_messages
+      result
+    end
+    
+    def self.call_sleep(app,result,duration,display_messages)
+      in_secs = WatchMe::Timer.to_seconds(duration)
+      result[:data] = in_secs
+      app.message.print_sleep(in_secs) if display_messages
+      Kernel.sleep(in_secs)
+      result
+    end
+
+    def self.call_ruby(app,result,call,display_messages)
+      result[:data] = eval(call)
+      app.message.print_ruby_call(call,result[:data]) if display_messages
+      result
+    end
+    
+  end
+  
+end

data/lib/registry/charlie_test.rb

@@ -0,0 +1,18 @@
+class CharlieTest
+
+  def self.handle?(cmd)
+    cmd.start_with?("charlie-test")
+  end
+
+  def self.available
+    { "charlie-test" => [] }
+  end
+  
+  def self.handle(app,cmd,display_messages)
+    result = app.default_result
+    result[:data] = cmd["charlie-test".size..-1].strip
+    app.console.print("CHARLIE: #{result[:data]}\n") if display_messages
+    result
+  end
+    
+end

data/lib/registry/echo_test.rb

@@ -0,0 +1,22 @@
+module Sample
+  
+  class EchoTest
+
+    def self.handle?(cmd)
+      cmd.start_with?("echo-test")
+    end
+    
+    def self.available
+      { "echo-test" => [] }
+    end
+
+    def self.handle(app,cmd,display_messages)
+      result = app.default_result
+      result[:data] = cmd["echo-test".size..-1].strip
+      app.console.print("ECHO: #{result[:data]}") if display_messages
+      result
+    end
+    
+  end
+  
+end

data/lib/registry/empty_registry.rb

@@ -0,0 +1,11 @@
+module Eve
+  
+  class EmptyRegistry < Registry
+        
+    def self.available
+      {}
+    end
+
+  end
+  
+end

data/spec/application_spec.rb

@@ -0,0 +1,738 @@
+require 'spec_helper'
+
+module Eve
+
+  describe Application do
+
+    before(:each) do
+      @now = Time.parse('2010-09-21 23:15:20')
+      @now_plus_four = Time.parse('2010-09-21 23:19:20')
+      @now_plus_six = Time.parse('2010-09-21 23:21:20')
+      Time.stub!(:now).and_return(@now)
+
+      `mkdir -p ./application_test`
+      `mkdir -p ./application_test2`
+      @redis = Utest::InmemoryRedis.new
+      @app = Application.new(:display => :string, :redis => @redis)
+    end
+    
+    after(:each) do
+      `rm -rf ./application_test`
+      `rm -rf ./application_test2`
+      `rm -f deleteme.txt deleteme2.txt`
+      `rm -rf ./eve.cmd`
+    end
+
+    describe "initialize" do
+      
+      it "should initalize things" do
+        @app.console.should_not == nil
+        @app.message.should_not == nil
+      end
+      
+      it "should pass display to console" do
+        @app.console.display.should == :string
+        
+        app = Application.new(:display => :stdio, :redis => @redis)
+        app.console.display.should == :stdio
+      end
+      
+      it "should map directly to messenger history" do
+        @app.history.should == @app.console.history
+      end
+      
+      it "should default mode to queue" do
+        @app = Application.new(:display => :string, :redis => @redis)
+        @redis.set("Eve.#{@app.id}.mode",nil)
+        @app.cmd("appid")
+        @app.mode.should == :queue
+      end
+      
+      it "should raise an error if id not set" do
+        @app = Application.new(:display => :string, :redis => @redis)
+        lambda { @app.lookup_id("blah") }.should raise_error
+      end
+    
+      describe "mode" do
+    
+        it "should default to fixed" do
+          @app = Application.new(:display => :string, :redis => @redis)
+          @app.mode.should == :queue
+        end
+            
+      end
+          
+      it "should set mode locally" do
+        @app = Application.new(:display => :string, :redis => @redis)
+        @app.mode.should == :queue
+        @app.mode = :poll
+        @app.mode.should == :poll
+      end
+      
+    end
+    
+    describe "#handle_args" do
+    
+      it "should accept an id" do
+        @app = Application.new(:display => :string, :redis => @redis)
+        @app.handle_args([ "--id", "123" ]).should == [ "appid 123" ]
+        @app.cmd("appid 123")
+        @app.id.should == "123"
+      end
+      
+      it "should set the id if not provided" do
+        redis = Utest::InmemoryRedis.new
+        @app = Application.new(:display => :string, :redis => redis)
+        @app.handle_args([]).should == [ "appid" ]
+        @app.cmd("appid")
+        @app.id.should == $$.to_s
+        Application.ids(redis).should == [ $$.to_s ]
+      end
+      
+      it "should default to check every 5 minutes (5*60 seconds)" do
+        @app.poll.should == 300
+        @app = Application.new(:display => :string, :redis => @redis)
+        @app.handle_args([ "--poll", "10minutes"]).should == [ "appid", "poll 10minutes" ]
+        @app.cmd("appid")
+        @app.cmd("poll set 10minutes")
+        @app.poll.should == 600
+      end
+      
+      it "should default to fixed" do
+        @app = Application.new(:display => :string, :redis => @redis)
+        @app.cmd("appid")
+        @app.mode.should == :queue
+      end
+    
+      describe "register" do
+    
+        it "should understand default" do
+          @app = Application.new(:display => :string, :redis => @redis)
+          @app.handle_args(["--register","Eve::BaseRegister","--shell"]).should == ["appid","register add Eve::BaseRegister","shell"]
+        end
+    
+        it "should understand both the name and " do
+          @app = Application.new(:display => :string, :redis => @redis)
+          @app.handle_args(["--register","AnotherRegister","/path/to/another_register.rb","--shell"]).should == ["appid","register add AnotherRegister /path/to/another_register.rb","shell"]
+        end
+    
+        it "should understand multiple" do
+          @app = Application.new(:display => :string, :redis => @redis)
+          @app.handle_args(["--register","Eve::BaseRegister","--register","AnotherRegister","/path/to/another_register.rb","--shell"]).should == ["appid","register add Eve::BaseRegister","register add AnotherRegister /path/to/another_register.rb","shell"]
+        end
+    
+      end
+    
+      it "should understand --shell" do
+        @app.handle_args(["--shell"]).should == ["appid","shell"]
+        @app.cmd("appid")
+        @app.cmd("shell")
+        @app.mode.should == :shell
+      end
+    
+      it "should understand --poll" do
+        @app.handle_args(["--poll","123"]).should == ["appid", "poll 123"]
+        @app.cmd("appid")
+        @app.cmd("poll set 123")
+        @app.mode.should == :poll
+        @app.poll.should == 123
+      end
+    
+      describe "event" do
+    
+        it "should understand --event" do
+          @app.handle_args(["--event", "1.1.1.1:4848"]).should == ["event 1.1.1.1:4848"]
+          @app.cmd("event")
+          @app.mode.should == :event
+        end
+        
+      end
+    
+      describe "run" do
+        
+        it "should understand --run" do
+          @app.handle_args(["--run","source", "add", "/tmp/source", "--run", "target", "add", "/tmp/target"]).should == ["appid","source add /tmp/source","target add /tmp/target"]
+        end
+        
+      end
+      
+    end
+    
+    describe "#lookup_id" do
+      
+      it "should be based on the app id" do
+        @app.id = 123
+        @app.lookup_id("Blah").should == "Eve.123.Blah"
+      end
+      
+    end
+    
+    # describe "#run" do
+    # 
+    #   it "should print the version" do
+    #     @app.run
+    #     @app.history.should == ["eve, version 0.1.2\n", "Appid: #{$$}\n", "bye\n"]
+    #   end
+    #       
+    #   it "should run the input commands" do
+    #     @app.stub!(:user_input).and_return("version","exit")
+    #     @app.run(["--shell"])
+    #     @app.history.should == ["eve, version 0.1.2\n", "Appid: #{$$}\n", "Entering shell mode, to exit this mode, type 'poll'\n", "eve #{$$}, version 0.1.2\n", "bye\n"]
+    #   end
+    #       
+    #   it "should set the id if provided" do
+    #     app = Application.new(:display => :string, :redis => @redis)
+    #     app.stub!(:user_input).and_return("exit")
+    #     app.run(["--id","abc123", "--shell"])
+    #     app.history.should == ["eve, version 0.1.2\n", "Appid: abc123\n", "Entering shell mode, to exit this mode, type 'poll'\n", "bye\n"]
+    #   end
+    #       
+    #   it "should exit if --interrupt" do
+    #     @app.mode = :poll
+    #     @app.run(["--interrupt", "acb123"])
+    #     @app.history.should == ["eve, version 0.1.2\n", "Interrupted eve acb123, should now be in shell mode\n", "bye\n"]
+    #   end
+    #   
+    #   it "should pop things off the queue" do
+    #     @app.cmd("appid")
+    #     @app.enqueue_cmd("version")
+    #     @app.enqueue_cmd("exit")
+    #     @app.run
+    #     @app.history.should == ["Appid: #{$$}\n", "eve #{$$}, version 0.1.2\n", "eve #{$$}, version 0.1.2\n", "bye\n"]
+    #   end
+    # 
+    # end
+    
+    describe "#cmd" do
+    
+      before(:each) do
+        @app.cmd("appid")
+        @app.reset
+      end
+    
+      describe "bam" do
+        
+        it "should report exceptions" do
+          @app.should_receive(:call_version).and_raise("bam!")
+          @app.cmd("version 1 2 3")
+          @app.history[0].should == "An error occurred for 'version 1 2 3'\n"
+          @app.history.size.should == 3
+        end
+        
+      end
+      
+      describe "appid" do
+        
+        it "should not call reload if no id provided" do
+          @app.should_not_receive(:call_register_reload)
+          @app.cmd("appid")
+        end
+    
+        it "should not call reload if new id" do
+          @app.should_not_receive(:call_register_reload)
+          @app.cmd("appid 1234")
+        end
+    
+        it "should call if it already exists" do
+          @redis.sadd("Eve.ApplicationIds","youreve")
+          @app.should_receive(:call_register_reload)
+          @app.cmd("appid youreve")
+        end
+    
+        
+      end
+    
+      describe "version" do
+    
+        it "should display the version" do
+          @app.cmd("version").should == { :data => "0.1.2", :status => :continue, :track_cmd => true }
+          @app.history.should == [ "eve #{$$}, version 0.1.2\n" ]
+        end
+        
+        it "should handle remote events via telnet" do
+          @app.cmd("event 0.0.0.0:1234")
+          telnet = mock(Net::Telnet)
+          Net::Telnet.should_receive(:new).with("Host" => "0.0.0.0", "Port" => "1234", "Timeout" => 10, "Telnetmode" => false).and_return(telnet)
+          telnet.should_receive(:cmd).with("version")
+          @app.cmd("version")
+        end
+    
+      end
+      
+      describe "help" do
+        
+        it "should diplay all help" do
+          
+          @app.cmd("help")[:data].should == Application.cmd_data
+          
+          expected = "Available commands are:\n"
+          expected += "  version\n"
+          expected += "  help\n"
+          expected += "  appid\n"
+          expected += "  shell\n"
+          expected += "  poll [ set | add | rm ]\n"
+          expected += "  event\n"
+          expected += "  remote\n"
+          expected += "  interrupt\n"
+          expected += "  register [ add | rm | reload | add-path | rm-path | path ]\n"
+          expected += "  print\n"
+          expected += "  exit\n"
+          
+          @app.history.should == [ expected ]
+        end
+    
+        it "should merge all" do
+          @app.cmd("register add CharlieTest #{File.dirname(__FILE__) + "/../lib/registry/charlie_test.rb"}")
+          @app.cmd("help")
+          
+          expected = "Available commands are:\n"
+          expected += "  version\n"
+          expected += "  help\n"
+          expected += "  appid\n"
+          expected += "  shell\n"
+          expected += "  poll [ set | add | rm ]\n"
+          expected += "  event\n"
+          expected += "  remote\n"
+          expected += "  interrupt\n"
+          expected += "  register [ add | rm | reload | add-path | rm-path | path ]\n"
+          expected += "  print\n"
+          expected += "  exit\n"
+          expected += "  charlie-test\n"
+          @app.history.should == [ expected ]
+        end
+        
+        it "should allow filtering based on handler" do
+          @app.cmd("register add CharlieTest #{File.dirname(__FILE__) + "/../lib/registry/charlie_test.rb"}")
+          @app.cmd("help CharlieTest")[:data].should == { "charlie-test" => [] }
+          expected = "Available commands (CharlieTest) are:\n"
+          expected += "  charlie-test\n"
+          @app.history.should == [ expected ]
+        end
+    
+        it "should not report unknown handlers" do
+          @app.cmd("help Blah")[:data].should == { }
+          expected = "Unknown handler Blah\n"
+          @app.history.should == [ expected ]
+        end
+        
+      end
+    
+      describe "exit" do
+        
+        it "should say bye" do
+          @app.cmd("exit").should == { :data => nil, :status => :exited, :track_cmd => true }
+          @app.history.should == [ "bye\n" ]
+        end
+    
+      end
+      
+      describe "shell" do
+        
+        it "should update mode" do
+          @app.cmd("shell").should == { :data => :shell, :status => :continue, :track_cmd => true }
+          @app.mode.should == :shell
+          @app.history.should == [ "Entering shell mode, to exit this mode, type 'poll'\n" ]
+        end
+        
+      end
+    
+      describe "poll" do
+        
+        it "should say nothing to poll" do
+          @app.cmd("poll")
+          @app.history.should == [ "Poll will check every 5 minutes (300 seconds), but it has nothing to run.\n" ]
+        end
+    
+        describe "add" do
+          
+          it "should add the cmd" do
+            result = @app.cmd("poll add do_blah a b c")
+            @app.cmd("poll")[:data].should == [ "do_blah a b c" ]
+          end
+    
+          it "should allow mulitple" do
+            result = @app.cmd("poll add do_blah a b c")
+            result = @app.cmd("poll add do_blah a b c")
+            @app.cmd("poll")[:data].should == [ "do_blah a b c", "do_blah a b c" ]
+          end
+    
+          it "should add in order" do
+            result = @app.cmd("poll add do_blah 1")
+            result = @app.cmd("poll add do_blah 2")
+            @app.cmd("poll")[:data].should == [ "do_blah 1", "do_blah 2" ]
+          end
+          
+        end
+        
+        describe "rm" do
+          
+          it "should rm the cmd at the particular index" do
+            result = @app.cmd("poll add do_blah 1")
+            result = @app.cmd("poll add do_blah 2")
+            result = @app.cmd("poll add do_blah 3")
+            @app.cmd("poll rm 2")
+            @app.cmd("poll rm 0")
+            @app.cmd("poll")[:data].should == [ "do_blah 2" ]
+          end
+    
+          it "should rm all instances of the cmd" do
+            result = @app.cmd("poll add do_blah a")
+            result = @app.cmd("poll add do_blah b")
+            result = @app.cmd("poll add do_blah a")
+            @app.cmd("poll rm do_blah a")
+            @app.cmd("poll")[:data].should == [ "do_blah b" ]
+          end
+    
+          it "should ignore unknown indexes" do
+            @app.cmd("poll rm 99")
+            @app.cmd("poll")[:data].should == [ ]            
+          end
+    
+          it "should allow mulitple" do
+            result = @app.cmd("poll add do_blah a b c")
+            result = @app.cmd("poll add do_blah a b c")
+            @app.cmd("poll")[:data].should == [ "do_blah a b c", "do_blah a b c" ]
+          end
+    
+          it "should add in order" do
+            result = @app.cmd("poll add do_blah 1")
+            result = @app.cmd("poll add do_blah 2")
+            @app.cmd("poll")[:data].should == [ "do_blah 1", "do_blah 2" ]
+          end
+          
+        end        
+        
+        describe "set" do
+    
+          it "should update how often it polls for data" do
+            @app.cmd("poll set 10minutes").should == { :data => 600, :status => :continue, :track_cmd => true }
+            @app.history.should == ["Entering poll mode with checks every 10 minutes (600 seconds), to exit this mode, run 'eve --interrupt #{$$}' from another terminal session\n"]
+          end
+    
+          it "should update mode" do
+            @app.id = "abc456"
+            @app.cmd("poll set 10").should == { :data => 10, :status => :continue, :track_cmd => true }
+            @app.mode.should == :poll
+            @app.history.should == ["Entering poll mode with checks every 10 seconds, to exit this mode, run 'eve --interrupt abc456' from another terminal session\n"]
+          end
+          
+          
+        end
+        
+      end
+    
+      describe "event" do
+        
+        it "should update mode" do
+          @app.cmd("event")
+          @app.mode.should == :event
+          @app.history.should == [ "Messages will be routed to 0.0.0.0:4848\n" ]
+        end
+        
+        it "should default the server ip and port" do
+          @app.cmd("event")[:data].should == { :server => "0.0.0.0", :port => "4848" }
+          @app.server.should == "0.0.0.0"
+          @app.port.should == "4848"
+        end
+    
+        it "should be overrideable" do
+          @app.cmd("event 1.1.1.1:2020")[:data].should == { :server => "1.1.1.1", :port => "2020" }
+          @app.server.should == "1.1.1.1"
+          @app.port.should == "2020"
+        end
+        
+      end      
+    
+      describe "interrupt" do
+        
+        it "should update mode" do
+          @redis.set("Eve.123.mode","poll")
+          @app.cmd("interrupt 123").should == { :data => nil, :status => :continue, :track_cmd => true }
+          @redis.get("Eve.123.mode").should == "shell"
+        end
+        
+      end
+      
+      describe "print" do
+        
+        it "should echo to the 'console'" do
+          @app.cmd("print hello my friends\nHow are you\n")
+          @app.history.should == [ "hello my friends\nHow are you\n" ]
+        end
+        
+      end
+    
+      describe "register" do
+        
+        it "should show nothing registered" do
+          result = @app.cmd("register")
+          result[:data].should == {}
+          @app.history.should == [ "Nothing registered.\n" ]
+        end
+        
+        it "Should show the class name and the filename" do
+          @app.cmd("register add CharlieTest")
+          @app.cmd("register add Sample::EchoTest")
+          result = @app.cmd("register")
+          
+          result[:data].should == { "CharlieTest" => [p("./lib/registry/charlie_test.rb")], "Sample::EchoTest" => [p("./lib/registry/echo_test.rb")] }
+          @app.history.should == [ "The following has been registered:\n  - CharlieTest (#{p("./lib/registry/charlie_test.rb")})\n  - Sample::EchoTest (#{p("./lib/registry/echo_test.rb")})\n" ]
+        end
+        
+        describe "path" do
+          
+          it "should show the default" do
+            @app.cmd("register path")
+            @app.history.should == [ "The following paths have been set:\n  -- #{p("#{File.dirname(__FILE__)}/../lib/registry")}\n" ]
+          end
+    
+          it "should also show any added paths" do
+            @app.cmd("register add-path ./application_test")
+            @app.reset
+            @app.cmd("register path")
+            @app.history.should == [ "The following paths have been set:\n  -- #{p("#{File.dirname(__FILE__)}/../lib/registry")}\n  -- #{p("./application_test")}\n" ]
+          end
+          
+        end
+        
+        describe "rm-path" do
+          
+          it "should ignore if not set" do
+            @app.cmd("register rm-path ./blah")[:data].should == 0
+          end
+    
+          it "should remove the path" do
+            @app.cmd("register add-path ./application_test")
+            @app.cmd("register add-path ./application_test2")
+            @app.reset
+            @app.cmd("register rm-path ./application_test")
+            @app.reset
+            @app.cmd("register path")
+            @app.history.should == [ "The following paths have been set:\n  -- #{p("#{File.dirname(__FILE__)}/../lib/registry")}\n  -- #{p("./application_test2")}\n" ]
+          end
+          
+        end        
+        
+        describe "add-path" do
+          
+          it "should validate path" do
+            result = @app.cmd("register add-path ./application_test")
+            result[:data].should == 1
+    
+            result = @app.cmd("register add-path ./unknown_dir")
+            result[:data].should == false
+          end
+    
+          it "should use path to load files" do
+            @app.cmd("register add-path #{File.dirname(__FILE__)}/files")
+            @app.cmd("register add Sample::NinerRegistry")
+            @app.cmd("register")
+            @app.history.should == [ "The following has been registered:\n  - Sample::NinerRegistry (#{p("#{File.dirname(__FILE__)}/files/niner_registry.rb")})\n" ]
+            @app.reset
+            @app.cmd("niner-test blah")[:data].should == "blah"
+            @app.history.should == [ "NINER: blah\n"]
+          end
+          
+          it "should allow for multiple handlers" do
+            @app.cmd("register add-path #{File.dirname(__FILE__)}/files")
+            @app.cmd("register add Sample::NinerRegistry")
+            @app.reset
+            result = @app.cmd("version")
+            result[:data][0][:data].should == "0.1.2"
+            result[:data][1][:data].should == "4848"
+            @app.history.should == [ "eve #{$$}, version 0.1.2\n", "version 4848\n" ]
+          end
+          
+
+        end
+        
+        describe "add" do
+          
+          it "should return a result" do
+            result = @app.cmd("register add CharlieTest")
+            result[:data].should == true
+    
+            result = @app.cmd("register add Blah")
+            result[:data].should == nil
+          end
+    
+          it "should look in registry if filename not provided" do
+            @app.cmd("register add CharlieTest")
+            @app.cmd("register add Sample::EchoTest")
+            @app.cmd("echo-test blah blah blah")[:data].should == "blah blah blah"
+            @app.cmd("charlie-test ra ra ra")[:data].should == "ra ra ra"
+          end
+    
+          it "should add extra calls" do
+            @app.cmd("register add CharlieTest #{File.dirname(__FILE__)}/../lib/registry/charlie_test.rb")
+            @app.cmd("register add Sample::EchoTest #{File.dirname(__FILE__) + "/../lib/registry/echo_test.rb"}")
+            @app.cmd("echo-test blah blah blah")[:data].should == "blah blah blah"
+            @app.cmd("charlie-test ra ra ra")[:data].should == "ra ra ra"
+          end
+    
+          it "should ignore unknown commands" do
+            @app.cmd("charlie-test ra ra ra")[:data].should == nil
+            @app.history.should == ["UNKNOWN CMD: charlie-test ra ra ra\n"]
+          end
+    
+          it "should not registry twice" do
+            @app.cmd("register add CharlieTest")
+            @app.cmd("register add CharlieTest")
+          end          
+        end
+        
+        describe "rm" do
+          
+          it "should return a result" do
+            @app.cmd("register add CharlieTest")
+            result = @app.cmd("register rm CharlieTest")
+            result[:data].should == 1
+    
+            result = @app.cmd("register rm Blah")
+            result[:data].should == 0
+          end
+    
+          it "should look in registry if filename not provided" do
+            @app.cmd("register add Sample::EchoTest")
+            @app.cmd("register rm Sample::EchoTest")
+            @app.cmd("echo-test blah blah blah")[:data].should == nil
+            @app.history.should == ["UNKNOWN CMD: echo-test blah blah blah\n"]
+          end
+    
+        end        
+        
+        describe "reload" do
+          
+          it "should reload what is in redis" do
+            @redis.sadd("Eve.#{$$}.registers","CharlieTest")
+            @redis.sadd("Eve.#{$$}.register_files","#{File.dirname(__FILE__)}/../lib/registry/charlie_test.rb")
+            @app.cmd("register reload")
+            @app.cmd("charlie-test ra ra ra")[:data].should == "ra ra ra"
+          end
+          
+        end
+        
+      end
+    
+    end
+    
+    describe "#alive?" do
+    
+      it "should check to see if process still running" do
+        Application.alive?($$).should == true
+        Application.alive?(-999).should == false
+      end
+    
+      it "should access nil / empty" do
+        Application.alive?(nil).should == false
+        Application.alive?("").should == false
+      end
+    
+    end
+    
+    describe "#system_call" do
+    
+      it "should track the command" do
+        IO.write("deleteme.txt","hello")
+        @app.system_call("cp deleteme.txt deleteme2.txt")
+        @app.system_calls.history.should == ["CALLING: cp deleteme.txt deleteme2.txt\n"]
+        File.exists?("deleteme2.txt").should == true
+        IO.read("deleteme2.txt").should == "hello"
+      end
+            
+    end
+    
+    describe "#self.ids" do
+      
+      it "should lookup in redis" do
+        redis = Utest::InmemoryRedis.new
+        
+        Application.ids(redis).should == []
+        
+        redis.sadd("Eve.ApplicationIds","123")
+        Application.ids(redis).should == [ "123" ]
+        
+        redis.sadd("Eve.ApplicationIds","456")
+        Application.ids(redis).should == [ "123", "456" ]
+      end
+      
+    end
+    
+    describe "#next_cmds" do
+      
+      before(:each) do
+        @app.cmd("appid")
+      end
+      
+      it "should grab from the queue first" do
+        @app.enqueue_cmd("version")
+        @app.next_cmds.should == ["version"]
+        @app.enqueue_cmd("source")
+        @app.next_cmds.should == ["source"]
+      end
+      
+      it "should quit if fixed" do
+        @app.mode = :queue
+        @app.next_cmds.should == ["exit"]
+      end
+    
+      it "should look to console if shell" do
+        @app.mode = :shell
+        @app.stub!(:user_input).and_return("version","exit")
+        @app.next_cmds.should == ["version"]
+      end
+    
+      it "should look to console if event" do
+        @app.mode = :event
+        @app.stub!(:user_input).and_return("version","exit")
+        @app.next_cmds.should == ["version"]
+        @app.next_cmds.should == ["exit"]
+      end
+      
+      describe "poll" do
+        
+        before(:each) do
+          @app.mode = :poll
+        end
+    
+        it "should be nothing if no sources/targets and on poll" do
+          @app.next_cmds.should == ["sleep 300"]
+        end
+    
+        it "should call the cmds and then sleep" do
+          @app.cmd("poll add do_blah a")
+          @app.cmd("poll add do_blah b")
+          @app.next_cmds.should == [ "do_blah a", "do_blah b", "sleep 300"]
+        end
+        
+      end
+    
+      it "should be gather if sources/targets and on poll" do
+        @app.mode = :poll
+        @app.cmd("source add /a/b/c")
+        @app.cmd("target add /a/b/d")
+        @app.next_cmds.should == ["sleep 300"]
+      end
+    
+    end
+    
+    describe "#post_init" do
+      
+      it "should say hello" do
+        @app.post_init
+        @app.history.should == [ "Connection Established\n" ]
+      end
+      
+    end
+    
+    describe "#receive_data" do
+      
+      it "should delegate to cmd" do
+        @app.should_receive(:cmd).with("blah",true,true)
+        @app.receive_data("blah")
+      end
+      
+    end
+
+  end
+end