eye 0.1.11

data/spec/child_process/child_process_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Eye::ChildProcess" do
+
+  before :each do
+    @pid = Eye::System.daemonize(C.p1[:start_command], C.p1)[:pid]
+    Eye::System.pid_alive?(@pid).should == true
+    sleep 0.5
+  end
+
+  it "some process was declared by my child" do
+    @process = Eye::ChildProcess.new(@pid, {})
+    @process.pid.should == @pid
+
+    @process.watchers.keys.should == []
+  end
+
+  describe "restart" do
+
+    it "kill by default command" do
+      @process = Eye::ChildProcess.new(@pid, {})
+      @process.schedule :restart
+
+      sleep 0.5
+      Eye::System.pid_alive?(@pid).should == false      
+    end  
+
+    it "kill by stop command" do
+      @process = Eye::ChildProcess.new(@pid, {:stop_command => "kill -9 {{PID}}"})
+      @process.schedule :restart
+
+      sleep 0.5
+      Eye::System.pid_alive?(@pid).should == false
+    end
+
+    it "try to snd URS1" do
+      @process = Eye::ChildProcess.new(@pid, {:stop_command => "kill -USR1 {{PID}}"})
+      @process.schedule :restart
+
+      sleep 0.5
+      Eye::System.pid_alive?(@pid).should == true
+    end
+  end
+
+end
+

data/spec/client_server_spec.rb

@@ -0,0 +1,34 @@
+# -*- encoding : utf-8 -*-
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Eye::Client, Eye::Server" do
+
+  before :each do
+    @socket_path = C.socket_path
+    @client = Eye::Client.new(@socket_path)
+    @server = Eye::Server.new(@socket_path)
+  end
+  
+  after :each do
+    @server.terminate
+  end
+  
+  it "client command, should send to controller" do
+    mock(Eye::Control).command('restart', 'samples'){ :command_sended }
+    mock(Eye::Control).command('stop'){ :command_sended2 }
+    @server.run!
+    sleep 0.1
+    
+    @client.command('restart', 'samples').should == :command_sended
+    @client.command('stop').should == :command_sended2
+  end  
+
+  it "another spec works too" do
+    mock(Eye::Control).command('stop'){ :command_sended2 }
+    @server.run!
+    sleep 0.1
+    
+    @client.command('stop').should == :command_sended2
+  end  
+
+end

data/spec/controller/commands_spec.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "comamnd spec" do
+  subject{ c = Eye::Controller.new; c.load(fixture("dsl/load.eye")); c }
+
+  before :each do
+    @apps = subject.applications
+
+    @app1 = @apps.first
+    @app2 = @apps.last
+
+    @gr1 = @app1.groups[0]
+    @gr2 = @app1.groups[1]
+    @gr3 = @app1.groups[2]
+    @gr4 = @app2.groups[0]
+
+    @p1 = @gr1.processes[0]
+    @p2 = @gr1.processes[1]
+    @p3 = @gr2.processes[0]
+    @p4 = @gr3.processes[0]
+    @p5 = @gr3.processes[1]
+    @p6 = @gr4.processes[0]
+  end
+
+  describe "remove objects" do
+    it "remove app" do
+      subject.remove_object_from_tree(@app2)
+      subject.applications.size.should == 1
+      subject.applications.first.should == @app1
+    end
+
+    it "remove group" do
+      subject.remove_object_from_tree(@gr1)
+      @app1.groups.should_not include(@gr1)
+
+      subject.remove_object_from_tree(@gr2)
+      @app1.groups.should_not include(@gr2)
+
+      subject.remove_object_from_tree(@gr3)
+      @app1.groups.should_not include(@gr3)
+
+      @app1.groups.should be_empty
+    end
+
+    it "remove process" do
+      subject.remove_object_from_tree(@p1)
+      @gr1.processes.should_not include(@p1)
+
+      subject.remove_object_from_tree(@p2)
+      @gr1.processes.should_not include(@p2)
+
+      @gr1.processes.should be_empty
+    end
+  end
+
+  describe "send_command" do
+    it "nothing" do
+      subject.load(fixture("dsl/load.eye")).should include(error: false)
+      subject.send_command(:start, "2341234").should == []
+    end
+
+    it "unknown" do
+      subject.load(fixture("dsl/load.eye")).should include(error: false)
+      subject.send_command(:st33art, "2341234").should == []
+    end
+
+    [:start, :stop, :restart, :unmonitor].each do |cmd|
+      it "should send_command #{cmd}" do
+        any_instance_of(Eye::Process) do |p|
+          dont_allow(p).send_command(cmd)          
+        end
+
+        mock(@p1).send_command(cmd)
+
+        subject.send_command cmd, "p1"
+      end
+    end
+
+    it "delete obj" do
+      any_instance_of(Eye::Process) do |p|
+        dont_allow(p).send_command(:delete)
+      end
+
+      mock(@p1).send_command(:delete)
+      subject.send_command :delete, "p1"
+
+      subject.all_processes.should_not include(@p1)
+      subject.all_processes.should include(@p2)
+    end
+  end
+
+end

data/spec/controller/controller_spec.rb

@@ -0,0 +1,133 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class String
+  def clean_info
+    self.gsub(%r{\033.*?m}im, '').gsub(%r[\(.*?\)], '')
+  end
+end
+
+def app_check(app, name, gr_size)
+  app.name.should == name
+  app.class.should == Eye::Application
+  app.groups.size.should == gr_size
+end
+
+def gr_check(gr, name, p_size, hidden = false)
+  gr.class.should == Eye::Group
+  gr.processes.size.should == p_size
+  gr.name.should == name
+  gr.hidden.should == hidden
+end
+
+def p_check(p, name, pid_file)
+  p.name.should == name
+  p.class.should == Eye::Process
+  p[:pid_file].should == "#{pid_file}"
+  p[:pid_file_ex].should == "/tmp/#{pid_file}"
+end
+
+describe "Eye::Controller" do
+  subject{ Eye::Controller.new }
+
+  it "should ok load config" do
+    subject.load(fixture("dsl/load.eye")).should include(error: false)
+
+    apps = subject.applications
+
+    app1 = apps.first
+    app_check(app1, 'app1', 3)
+    app2 = apps.last
+    app_check(app2, 'app2', 1)
+
+    gr1 = app1.groups[0]
+    gr_check(gr1, 'gr1', 2, false)
+    gr2 = app1.groups[1]
+    gr_check(gr2, 'gr2', 1, false)
+    gr3 = app1.groups[2]
+    gr_check(gr3, '__default__', 2, true)
+    gr4 = app2.groups[0]
+    gr_check(gr4, '__default__', 1, true)
+
+    p1 = gr1.processes[0]
+    p_check(p1, 'p1', "app1-gr1-p1.pid")
+    p2 = gr1.processes[1]
+    p_check(p2, 'p2', "app1-gr1-p2.pid")
+
+    p3 = gr2.processes[0]
+    p_check(p3, 'q3', "app1-gr2-q3.pid")
+
+    p4 = gr3.processes[0]
+    p_check(p4, 'g4', "app1-g4.pid")
+    p5 = gr3.processes[1]
+    p_check(p5, 'g5', "app1-g5.pid")
+
+    p6 = gr4.processes[0]
+    p_check(p6, 'z1', "app2-z1.pid")
+  end
+
+  it "raise when load config" do
+    subject.load(fixture("dsl/bad.eye")).should include(:error => true, :message => "blank pid_file for: bad")
+  end
+
+  it "info_string" do
+    app1 = <<S
+app1                       
+  gr1                               [monitor 1 of 2]
+    p1 ............................ unmonitored 
+    p2 ............................ unmonitored
+  gr2                              
+    q3 ............................ unmonitored 
+  g4 .............................. unmonitored 
+  g5 .............................. unmonitored
+S
+    app2 = <<S
+app2                       
+  z1 .............................. unmonitored
+S
+
+    subject.load(fixture("dsl/load.eye"))
+    subject.info_string.clean_info.strip.should == (app1 + app2).strip
+    subject.info_string('app1').clean_info.should == app1.chomp
+    subject.info_string('app2').clean_info.strip.should == app2.strip
+    subject.info_string('app3').clean_info.should == ''
+  end
+
+  it "info_string_debug should be" do
+    subject.load(fixture("dsl/load.eye"))
+    subject.info_string_debug.split("\n").size.should > 10
+  end
+
+  it "info_string_short should be" do
+    subject.load(fixture("dsl/load.eye"))
+    subject.info_string_short.split("\n").size.should == 2
+  end
+
+  describe "command" do
+    it "should send_command" do
+      mock(Eye::Control).send_command(:restart, 'samples')
+      Eye::Control.command('restart', 'samples')
+    end
+
+    it "should send_command" do
+      mock(Eye::Control).send_command(:restart)
+      Eye::Control.command(:restart)
+    end
+
+    it "load" do
+      mock(Eye::Control).load('/tmp/file')
+      Eye::Control.command('load', '/tmp/file')
+    end
+
+    it "info" do
+      mock(Eye::Control).info_string
+      Eye::Control.command('info')
+    end
+
+    it "quit" do
+      mock(Eye::Control).quit
+      Eye::Control.command('quit')
+    end
+
+  end
+
+end

data/spec/controller/find_objects_spec.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "find_objects" do
+  subject{ c = Eye::Controller.new; c.load(fixture("dsl/load.eye")); c }
+
+  it "1 process" do
+    objs = subject.find_objects("p1")
+    objs.map{|c| c.class}.should == [Eye::Process]
+    objs.map{|c| c.name}.sort.should == %w{p1}
+  end
+
+  it "1 group" do
+    objs = subject.find_objects("gr2")
+    objs.map{|c| c.class}.should == [Eye::Group]
+    objs.map{|c| c.name}.sort.should == %w{gr2}
+  end
+
+  it "1 app" do
+    objs = subject.find_objects("app2")
+    objs.map{|c| c.class}.should == [Eye::Application]
+    objs.map{|c| c.name}.sort.should == %w{app2}
+  end
+
+  it "find * processes by mask" do
+    objs = subject.find_objects("p*")
+    objs.map{|c| c.class}.should == [Eye::Process, Eye::Process]
+    objs.map{|c| c.name}.sort.should == %w{p1 p2}
+  end
+
+  it "find * groups by mask" do
+    objs = subject.find_objects("gr*")
+    objs.map{|c| c.class}.should == [Eye::Group, Eye::Group]
+    objs.map{|c| c.name}.sort.should == %w{gr1 gr2}
+  end
+
+  it "find * apps by mask" do
+    objs = subject.find_objects("app*")
+    objs.map{|c| c.class}.should == [Eye::Application, Eye::Application]
+    objs.map{|c| c.name}.sort.should == %w{app1 app2}
+  end
+
+  it "find by ','" do
+    objs = subject.find_objects("p1,p2")
+    objs.map{|c| c.class}.should == [Eye::Process, Eye::Process]
+    objs.map{|c| c.name}.sort.should == %w{p1 p2}
+  end
+
+  it "find by many params" do
+    objs = subject.find_objects("p1", "p2")
+    objs.map{|c| c.class}.should == [Eye::Process, Eye::Process]
+    objs.map{|c| c.name}.sort.should == %w{p1 p2}
+  end
+
+  it "find * apps by mask" do
+    objs = subject.find_objects("z*\n")
+    objs.map{|c| c.class}.should == [Eye::Process]
+    objs.map{|c| c.name}.sort.should == %w{z1}
+  end
+
+  it "empty, find nothing" do
+    subject.find_objects("").should == []
+  end
+
+  it "'all', find all projects" do
+    objs = subject.find_objects("all")
+    objs.map{|c| c.class}.should == [Eye::Application, Eye::Application]
+    objs.map{|c| c.name}.sort.should == %w{app1 app2}
+  end
+
+  it "nothing" do
+    subject.find_objects("asdfasdf").should == []
+  end
+
+  describe "find by routes" do
+    it "group" do
+      objs = subject.find_objects("app1:gr2")
+      obj = objs.first
+      obj.class.should == Eye::Group
+      obj.full_name.should == 'app1:gr2'
+    end
+
+    it "group + mask" do
+      objs = subject.find_objects("app1:gr*")
+      objs.map{|c| c.class}.should == [Eye::Group, Eye::Group]
+      objs.map{|c| c.name}.sort.should == %w{gr1 gr2}
+    end
+
+    it "process" do
+      objs = subject.find_objects("app1:gr2:q3")
+      obj = objs.first
+      obj.class.should == Eye::Process
+      obj.full_name.should == 'app1:gr2:q3'
+    end
+
+    describe "dubls" do
+      subject{ c = Eye::Controller.new; c.load(fixture("dsl/load_dubls.eye")); c }
+
+      it "not found" do
+        subject.find_objects("z").should == []
+      end
+
+      it "found 2 processed" do
+        objs = subject.find_objects("z*")
+        objs.map{|c| c.class}.should == [Eye::Process, Eye::Process]
+        objs.map{|c| c.name}.sort.should == %w{z1 z2}
+      end
+
+      it "find by gr1" do
+        objs = subject.find_objects("gr1")
+        objs.map{|c| c.class}.should == [Eye::Group, Eye::Group]
+        objs.map{|c| c.full_name}.sort.should == %w{app1:gr1 app2:gr1}
+      end
+
+      it "correct by gr*" do
+        objs = subject.find_objects("gr*")
+        objs.map{|c| c.class}.should == [Eye::Group, Eye::Group, Eye::Group, Eye::Process]
+        objs.map{|c| c.full_name}.should == %w{app1:gr1 app1:gr2 app2:gr1 app1:gr2and}
+      end
+
+      it "correct by gr1*" do
+        objs = subject.find_objects("gr1*")
+        objs.map{|c| c.class}.should == [Eye::Group, Eye::Group]
+        objs.map{|c| c.full_name}.sort.should == %w{app1:gr1 app2:gr1}
+      end
+
+      it "correct process" do
+        objs = subject.find_objects("gr1and")
+        objs.map{|c| c.class}.should == [Eye::Process]
+        objs.map{|c| c.full_name}.sort.should == %w{app2:gr1:gr1and}
+      end
+    end
+  end
+
+  describe "missing" do
+    it "should not found" do
+      subject.find_objects("app1:gr2:q").should == []
+      subject.find_objects("gr1:p1").should == []
+      subject.find_objects("pp1").should == []
+      subject.find_objects("app1::").should == []
+      subject.find_objects("app1:").should == []
+    end
+  end
+
+  describe "match" do
+    it "should match" do
+      subject.match("gr*").should == ["app1:gr1", "app1:gr2"]
+    end
+  end
+
+end