eye 0.2.4 → 0.3

data/spec/controller/controller_spec.rb

@@ -1,157 +0,0 @@
-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
-  app.groups.class.should == Eye::Utils::AliveArray
-end
-
-def gr_check(gr, name, p_size, hidden = false)
-  gr.class.should == Eye::Group
-  gr.processes.class.should == Eye::Utils::AliveArray
-  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)
-    app1.processes.map(&:name).sort.should == ["g4", "g5", "p1", "p2", "q3"]
-
-    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 > 5
-  end
-
-  it "info_string_short should be" do
-    subject.load(fixture("dsl/load.eye"))
-    subject.info_string_short.split("\n").size.should == 2
-  end
-
-  it "history_string" do
-    subject.load(fixture("dsl/load.eye"))
-    str = subject.history_string('*')
-    str.should be_a(String)
-    str.size.should > 100
-  end
-
-  it "history_data" do
-    subject.load(fixture("dsl/load.eye"))
-    h = subject.history_data('app1')
-    h.size.should == 5
-    h.keys.sort.should == ["app1:g4", "app1:g5", "app1:gr1:p1", "app1:gr1:p2", "app1:gr2:q3"]
-  end
-
-  it "should delete all apps" do
-    subject.load(fixture("dsl/load.eye")).should include(error: false)
-    subject.send_command(:delete, 'all')
-    subject.applications.should be_empty
-  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

@@ -1,176 +0,0 @@
-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 "'*', find all projects" do
-    objs = subject.find_objects("*")
-    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 "submatching without * " do
-    it "match by start symbols, apps" 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 "match by start symbols, groups" 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 "match by start symbols, process" do
-      objs = subject.find_objects("z")
-      objs.map{|c| c.class}.should == [Eye::Process]
-      objs.map{|c| c.name}.sort.should == %w{z1}
-    end
-  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("zu").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:gr4").should == []
-      subject.find_objects("gr:p").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

data/spec/controller/group_spec.rb

@@ -1,110 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Eye::Group" do
-
-  describe "Chain calls" do
-
-    it "should call chain_schedule for start" do
-      @g = Eye::Group.new('gr', {:chain => {:start => {:type => :async, :command => :start, :grace => 7}}})
-      mock(@g).chain_schedule(:async, 7, :start)
-      @g.start
-    end
-
-    it "should call chain_schedule for start, with type sync" do
-      @g = Eye::Group.new('gr', {:chain => {:start => {:type => :sync, :command => :start, :grace => 7}}})
-      mock(@g).chain_schedule(:sync, 7, :start)
-      @g.start
-    end
-
-    it "config for start and restart, use both" do
-      @g = Eye::Group.new('gr', {:chain => {:start => {:type => :async, :command => :start, :grace => 7}, :restart => {:type => :sync, :command => :restart, :grace => 8}}})
-      mock(@g).chain_schedule(:async, 7, :start)
-      @g.start
-
-      mock(@g).chain_schedule(:sync, 8, :restart)
-      @g.restart
-    end
-
-    it "should use options type" do
-      @g = Eye::Group.new('gr', {:chain => {:start => {:type => :sync, :command => :start}}})
-      mock(@g).chain_schedule(:sync, Eye::Group::DEFAULT_CHAIN, :start)
-      @g.start
-    end
-
-    it "with empty grace, should call default grace 0" do
-      @g = Eye::Group.new('gr', {:chain => {:start => {:command => :start}}})
-      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :start)
-      @g.start
-    end
-
-    it "chain options for restart, but called start, should call chain but with default options" do
-      @g = Eye::Group.new('gr', {:chain => {:start => {:command => :restart}}})
-      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :restart)
-      @g.restart
-    end
-
-    it "restart without grace, should call default grace 0" do
-      @g = Eye::Group.new('gr', {:chain => {:restart => {:command => :restart}}})
-      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :restart)
-      @g.restart
-    end
-
-    it "restart with invalid type, should call with async" do
-      @g = Eye::Group.new('gr', {:chain => {:restart => {:command => :restart, :type => [12324]}}})
-      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :restart)
-      @g.restart
-    end
-
-    it "restart with invalid grace, should call default grace 0" do
-      @g = Eye::Group.new('gr', {:chain => {:restart => {:command => :restart, :grace => []}}})
-      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :restart)
-      @g.restart
-    end
-
-    it "restart with invalid grace, should call default grace 0" do
-      @g = Eye::Group.new('gr', {:chain => {:restart => {:command => :restart, :grace => :some_error}}})
-      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :restart)
-      @g.restart
-    end
-
-    it "restart with empty config, should call chain_schedule" do
-      @g = Eye::Group.new('gr', {})
-      mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :restart)
-      @g.restart
-    end
-
-    it "when chain clearing by force" do
-      @g = Eye::Group.new('gr', {:chain => {:start => {:command => :start, :grace => 0}, :restart => {:command => :restart, :grace => 0}}})      
-      mock(@g).chain_schedule(:async, 0, :monitor)
-      @g.monitor
-
-      mock(@g).chain_schedule(:async, 0, :restart)
-      @g.restart
-
-      mock(@g).chain_schedule(:async, 0, :start)
-      @g.start
-    end
-
-    it "with params" do
-      @g = Eye::Group.new('gr', {})
-      mock(@g).async_schedule(:signal, 15)
-      @g.signal(15)
-    end
-
-    describe "monitor using chain as start" do
-      it "monitor call chain" do
-        @g = Eye::Group.new('gr', {:chain => {:start => {:command => :start, :grace => 3}}})
-        mock(@g).chain_schedule(:async, 3, :monitor)
-        @g.monitor
-      end
-
-      it "monitor not call chain" do
-        @g = Eye::Group.new('gr', {:chain => {:restart => {:command => :restart, :grace => 3}}})
-        mock(@g).chain_schedule(:async, Eye::Group::DEFAULT_CHAIN, :monitor)
-        @g.monitor
-      end
-    end
-
-  end
-
-end

data/spec/controller/intergration_spec.rb

@@ -1,366 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Intergration" do
-  before :each do
-    @c = Eye::Controller.new
-    @c.load(fixture("dsl/integration.eye"))
-    @processes = @c.all_processes
-    @p1 = @processes.detect{|c| c.name == 'sample1'}
-    @p2 = @processes.detect{|c| c.name == 'sample2'}
-    @p3 = @processes.detect{|c| c.name == 'forking'}
-    @samples = @c.all_groups.detect{|c| c.name == 'samples'}
-    sleep 10 # to ensure that all processes started
-
-    @processes.size.should == 3
-    @processes.map{|c| c.state_name}.uniq.should == [:up]
-    @childs = @p3.childs.keys rescue []
-
-    @c.info_string.split("\n").size.should == 8
-    @c.info_string.strip.size.should > 100
-  end
-
-  after :each do
-    @processes.each do |p|
-      p.schedule(:stop) if p.alive?
-    end
-    sleep 5
-    @processes.each do |process|
-      force_kill_process(process) if process.alive?
-    end
-
-    force_kill_pid(@old_pid1)
-    force_kill_pid(@old_pid2)
-    force_kill_pid(@old_pid3)
-    (@childs || []).each do |pid|
-      force_kill_pid(pid)
-    end
-  end
-
-  it "restart process group samples" do
-    @old_pid1 = @p1.pid
-    @old_pid2 = @p2.pid
-    @old_pid3 = @p3.pid
-    @c.send_command(:restart, "samples")
-    sleep 11 # while they restarting
-
-    @processes.map{|c| c.state_name}.uniq.should == [:up]
-    @p1.pid.should_not == @old_pid1
-    @p2.pid.should_not == @old_pid2
-    @p3.pid.should == @old_pid3
-  end
-
-  it "restart process" do
-    @old_pid1 = @p1.pid
-    @old_pid2 = @p2.pid
-    @old_pid3 = @p3.pid
-    @c.send_command(:restart, "sample1")
-    sleep 10 # while they restarting
-
-    @processes.map{|c| c.state_name}.uniq.should == [:up]
-    @p1.pid.should_not == @old_pid1
-    @p2.pid.should == @old_pid2
-    @p3.pid.should == @old_pid3
-  end
-
-  it "restart process forking" do
-    @old_pid1 = @p1.pid
-    @old_pid2 = @p2.pid
-    @old_pid3 = @p3.pid
-    @c.send_command(:restart, "forking")
-    sleep 11 # while they restarting
-
-    @processes.map{|c| c.state_name}.uniq.should == [:up]
-    @p1.pid.should == @old_pid1
-    @p2.pid.should == @old_pid2
-    @p3.pid.should_not == @old_pid3
-
-    @p1.last_scheduled_reason.should == 'monitor by user'
-    @p3.last_scheduled_reason.should == 'restart by user'
-  end
-
-  it "restart forking named child" do
-    @p3.childs.size.should == 3
-    dead_pid = @p3.childs.keys.sample
-
-    @c.send_command(:restart, "child-#{dead_pid}").should == ["int:forking:child-#{dead_pid}"]
-    sleep 11 # while it
-
-    new_childs = @p3.childs.keys
-    new_childs.size.should == 3
-    new_childs.should_not include(dead_pid)
-    (@childs - [dead_pid]).each do |pid|
-      new_childs.should include(pid)
-    end
-  end
-
-  it "restart missing" do
-    @old_pid1 = @p1.pid
-    @old_pid2 = @p2.pid
-    @old_pid3 = @p3.pid
-    @c.send_command(:restart, "blabla").should == []
-    sleep 1
-    @processes.map{|c| c.state_name}.uniq.should == [:up]
-    @p1.pid.should == @old_pid1
-    @p2.pid.should == @old_pid2
-    @p3.pid.should == @old_pid3
-  end
-
-  describe "chain" do
-    it "restart group with chain sync" do
-      @samples.config.merge!(:chain => C.restart_sync)
-
-      @old_pid1 = @p1.pid
-      @old_pid2 = @p2.pid
-      @old_pid3 = @p3.pid
-      @c.send_command(:restart, "samples")
-      sleep 15 # while they restarting
-
-      @processes.map{|c| c.state_name}.uniq.should == [:up]
-      @p1.pid.should_not == @old_pid1
-      @p2.pid.should_not == @old_pid2
-      @p3.pid.should == @old_pid3
-
-      r1 = @p1.states_history.detect{|c| c[:state] == :restarting}[:at]
-      r2 = @p2.states_history.detect{|c| c[:state] == :restarting}[:at]
-
-      # >8 because, grace start, and grace stop added
-      (r2 - r1).should >= 8
-    end
-
-    it "restart group with chain async" do
-      @samples.config.merge!(:chain => C.restart_async)
-
-      @old_pid1 = @p1.pid
-      @old_pid2 = @p2.pid
-      @old_pid3 = @p3.pid
-      @c.send_command(:restart, "samples")
-      sleep 15 # while they restarting
-
-      @processes.map{|c| c.state_name}.uniq.should == [:up]
-      @p1.pid.should_not == @old_pid1
-      @p2.pid.should_not == @old_pid2
-      @p3.pid.should == @old_pid3
-
-      r1 = @p1.states_history.detect{|c| c[:state] == :restarting}[:at]
-      r2 = @p2.states_history.detect{|c| c[:state] == :restarting}[:at]
-
-      # restart sended, in 5 seconds to each
-      (r2 - r1).should be_within(0.2).of(5)
-    end
-
-    it "if processes dead in chain restart, nothing raised" do
-      @samples.config.merge!(:chain => C.restart_async)
-
-      @old_pid1 = @p1.pid
-      @old_pid2 = @p2.pid
-      @old_pid3 = @p3.pid
-      @c.send_command(:restart, "samples")
-      sleep 3
-
-      # in the middle of the process, we kill all processes
-      @p1.terminate
-      @p2.terminate
-
-      sleep 3
-
-      # nothing happens
-      @samples.alive?.should == true
-    end
-
-    it "chain breaker breaks current chain and all pending requests" do
-      @samples.config.merge!(:chain => C.restart_async)
-
-      @c.send_command(:restart, "samples")
-      @c.send_command(:stop, "samples")
-      sleep 0.5
-
-      @samples.current_scheduled_command.should == :restart
-      @samples.scheduler_actions_list.should == [:stop]
-
-      @c.send_command(:break_chain, "samples")
-      sleep 3
-      @samples.current_scheduled_command.should == :restart
-      sleep 2
-      @samples.current_scheduled_command.should == nil
-      @samples.scheduler_actions_list.should == []
-
-      sleep 1
-
-      # only first process should be restarted
-      @p1.last_scheduled_command.should == :restart
-      @p2.last_scheduled_command.should == :monitor
-    end
-  end
-
-  it "stop group" do
-    @old_pid1 = @p1.pid
-    @old_pid2 = @p2.pid
-    @old_pid3 = @p3.pid
-    @c.send_command(:stop, "samples")
-    sleep 7 # while they stopping
-
-    @p1.state_name.should == :unmonitored
-    @p2.state_name.should == :unmonitored
-    @p3.state_name.should == :up
-
-    Eye::System.pid_alive?(@old_pid1).should == false
-    Eye::System.pid_alive?(@old_pid2).should == false
-    Eye::System.pid_alive?(@old_pid3).should == true
-
-    sth = @p1.states_history.last
-    sth[:reason].should == 'stop by user'
-    sth[:state].should == :unmonitored
-  end
-
-  it "stop process" do
-    @old_pid1 = @p1.pid
-    @old_pid2 = @p2.pid
-    @old_pid3 = @p3.pid
-
-    @c.send_command(:stop, "sample1")
-    sleep 7 # while they stopping
-
-    @p1.state_name.should == :unmonitored
-    @p2.state_name.should == :up
-    @p3.state_name.should == :up
-
-    Eye::System.pid_alive?(@old_pid1).should == false
-    Eye::System.pid_alive?(@old_pid2).should == true
-    Eye::System.pid_alive?(@old_pid3).should == true
-  end
-
-  it "unmonitor process" do
-    @old_pid1 = @p1.pid
-    @old_pid2 = @p2.pid
-    @old_pid3 = @p3.pid
-
-    @c.send_command(:unmonitor, "sample1").should == ["int:samples:sample1"]
-    sleep 7 # while they stopping
-
-    @p1.state_name.should == :unmonitored
-    @p2.state_name.should == :up
-    @p3.state_name.should == :up
-
-    Eye::System.pid_alive?(@old_pid1).should == true
-    Eye::System.pid_alive?(@old_pid2).should == true
-    Eye::System.pid_alive?(@old_pid3).should == true
-  end
-
-  it "send signal to process throught all schedules" do
-    mock(@p1).signal('usr2')
-    mock(@p2).signal('usr2')
-    mock(@p3).signal('usr2')
-
-    @c.signal('usr2', "int").should == ["int"]
-    sleep 3 # while they gettings
-
-    @p1.last_scheduled_command.should == :signal
-    @p1.last_scheduled_reason.should == 'signal by user'
-
-    mock(@p1).signal('usr1')
-    @c.signal('usr1', 'sample1')
-    sleep 0.5
-  end
-
-  describe "delete" do
-    it "delete group not monitoring anymore" do
-      @old_pid1 = @p1.pid
-      @old_pid2 = @p2.pid
-      @old_pid3 = @p3.pid
-
-      @c.send_command(:delete, "samples").should == ["int:samples"]
-      sleep 7 # while 
-
-      @c.all_processes.should == [@p3]
-      @c.all_groups.map(&:name).should == ['__default__']
-
-      Eye::System.pid_alive?(@old_pid1).should == true
-      Eye::System.pid_alive?(@old_pid2).should == true
-      Eye::System.pid_alive?(@old_pid3).should == true
-
-      Eye::System.send_signal(@old_pid1)
-      sleep 0.5
-      Eye::System.pid_alive?(@old_pid1).should == false
-
-      # noone up this
-      sleep 2
-      Eye::System.pid_alive?(@old_pid1).should == false
-    end
-
-    it "delete process not monitoring anymore" do
-      @old_pid1 = @p1.pid
-      @old_pid2 = @p2.pid
-      @old_pid3 = @p3.pid
-
-      @c.send_command(:delete, "sample1")
-      sleep 7 # while 
-
-      @c.all_processes.map(&:name).sort.should == %w{forking sample2}
-      @c.all_groups.map(&:name).sort.should == %w{__default__ samples}
-      @c.group_by_name('samples').processes.full_size.should == 1
-      @c.group_by_name('samples').processes.map(&:name).should == %w{sample2}
-
-      Eye::System.pid_alive?(@old_pid1).should == true
-      Eye::System.pid_alive?(@old_pid2).should == true
-      Eye::System.pid_alive?(@old_pid3).should == true
-
-      Eye::System.send_signal(@old_pid1)
-      sleep 0.5
-      Eye::System.pid_alive?(@old_pid1).should == false
-    end
-
-    it "delete application" do
-      @old_pid1 = @p1.pid
-      @old_pid2 = @p2.pid
-      @old_pid3 = @p3.pid
-
-      @c.send_command(:delete, "int")
-      sleep 7 # while 
-
-      @c.all_processes.should == []
-      @c.all_groups.should == []
-      @c.applications.should == []
-
-      Eye::System.pid_alive?(@old_pid1).should == true
-      Eye::System.pid_alive?(@old_pid2).should == true
-      Eye::System.pid_alive?(@old_pid3).should == true
-
-      Eye::System.send_signal(@old_pid1)
-      sleep 0.5
-      Eye::System.pid_alive?(@old_pid1).should == false
-
-      actors = Celluloid::Actor.all.map(&:class)
-      actors.should_not include(Eye::Utils::CelluloidChain)
-      actors.should_not include(Eye::Process)
-      actors.should_not include(Eye::Group)
-      actors.should_not include(Eye::Application)
-      actors.should_not include(Eye::Checker::Memory)
-    end
-
-    it "delete by mask" do
-      @old_pid1 = @p1.pid
-      @old_pid2 = @p2.pid
-      @old_pid3 = @p3.pid
-
-      @c.send_command(:delete, "sam*").should == ["int:samples"]
-      sleep 7 # while 
-
-      @c.all_processes.should == [@p3]
-      @c.all_groups.map(&:name).should == ['__default__']
-
-      Eye::System.pid_alive?(@old_pid1).should == true
-      Eye::System.pid_alive?(@old_pid2).should == true
-      Eye::System.pid_alive?(@old_pid3).should == true
-
-      Eye::System.send_signal(@old_pid1)
-      sleep 0.5
-      Eye::System.pid_alive?(@old_pid1).should == false
-
-      # noone up this
-      sleep 2
-      Eye::System.pid_alive?(@old_pid1).should == false
-    end
-  end
-
-
-end