eye 0.2.4 → 0.3

data/spec/controller/load_spec.rb

@@ -1,371 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Eye::Controller::Load" do
-  subject{ Eye::Controller.new }
-
-  it "blank" do
-    subject.load.should == {:error => true, :message => "config file '' not found!"}
-  end
-
-  it "not exists file" do
-    subject.load("/asdf/asd/fasd/fas/df/sfd").should == {:error => true, :message => "config file '/asdf/asd/fasd/fas/df/sfd' not found!"}
-  end
-
-  it "load 1 app" do
-    subject.load(fixture("dsl/load.eye")).should include(error: false)
-    subject.short_tree.should == {
-      "app1"=>{
-        "gr1"=>{"p1"=>"/tmp/app1-gr1-p1.pid", "p2"=>"/tmp/app1-gr1-p2.pid"}, 
-        "gr2"=>{"q3"=>"/tmp/app1-gr2-q3.pid"}, 
-        "__default__"=>{"g4"=>"/tmp/app1-g4.pid", "g5"=>"/tmp/app1-g5.pid"}}, 
-      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}}
-  end
-
-  it "load correctly application, groups for full_names processes" do
-    subject.load(fixture("dsl/load.eye")).should include(error: false)
-
-    p1 = subject.process_by_name('p1')
-    p1[:application].should == 'app1'
-    p1[:group].should == 'gr1'
-    p1.name.should == 'p1'
-    p1.full_name.should == 'app1:gr1:p1'
-
-    gr1 = subject.group_by_name 'gr1'
-    gr1.full_name.should == 'app1:gr1'
-
-    g4 = subject.process_by_name('g4')
-    g4[:application].should == 'app1'
-    g4[:group].should == '__default__'
-    g4.name.should == 'g4'
-    g4.full_name.should == 'app1:g4'
-  end
-
-  it "load + 1new app" do
-    subject.load(fixture("dsl/load.eye")).should include(error: false)
-    subject.short_tree.should == {
-      "app1"=>{
-        "gr1"=>{"p1"=>"/tmp/app1-gr1-p1.pid", "p2"=>"/tmp/app1-gr1-p2.pid"}, 
-        "gr2"=>{"q3"=>"/tmp/app1-gr2-q3.pid"}, 
-        "__default__"=>{"g4"=>"/tmp/app1-g4.pid", "g5"=>"/tmp/app1-g5.pid"}}, 
-      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}}
-
-    subject.load(fixture("dsl/load2.eye")).should include(error: false)
-
-    subject.short_tree.should == {
-      "app1"=>{
-        "gr1"=>{"p1"=>"/tmp/app1-gr1-p1.pid", "p2"=>"/tmp/app1-gr1-p2.pid"}, 
-        "gr2"=>{"q3"=>"/tmp/app1-gr2-q3.pid"}, 
-        "__default__"=>{"g4"=>"/tmp/app1-g4.pid", "g5"=>"/tmp/app1-g5.pid"}}, 
-      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}, 
-      "app3"=>{"__default__"=>{"e1"=>"/tmp/app3-e1.pid"}}}
-  end
-
-  it "load 1 changed app" do
-    subject.load(fixture("dsl/load.eye")).should include(error: false)
-    subject.load(fixture("dsl/load2.eye")).should include(error: false)
-
-    p = subject.process_by_name('e1')
-    p[:daemonize].should == false
-
-    proxy(p).schedule :update_config, is_a(Hash), is_a(String)
-    dont_allow(p).schedule :monitor
-
-    subject.load(fixture("dsl/load3.eye")).should include(error: false)
-
-    subject.short_tree.should == {
-      "app1"=>{
-        "gr1"=>{"p1"=>"/tmp/app1-gr1-p1.pid", "p2"=>"/tmp/app1-gr1-p2.pid"}, 
-        "gr2"=>{"q3"=>"/tmp/app1-gr2-q3.pid"}, 
-        "__default__"=>{"g4"=>"/tmp/app1-g4.pid", "g5"=>"/tmp/app1-g5.pid"}}, 
-      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}, 
-      "app3"=>{"wow"=>{"e1"=>"/tmp/app3-e1.pid"}}}
-
-    sleep 0.1
-    p2 = subject.process_by_name('e1')
-    p2[:daemonize].should == true
-
-    p.object_id.should == p2.object_id
-  end
-
-  it "load -> delete -> load" do
-    subject.load(fixture("dsl/load.eye")).should include(error: false)
-    subject.load(fixture("dsl/load2.eye")).should include(error: false)
-    subject.command(:delete, 'app3')
-    subject.load(fixture("dsl/load3.eye")).should include(error: false)
-
-    subject.short_tree.should == {
-      "app1"=>{
-        "gr1"=>{"p1"=>"/tmp/app1-gr1-p1.pid", "p2"=>"/tmp/app1-gr1-p2.pid"}, 
-        "gr2"=>{"q3"=>"/tmp/app1-gr2-q3.pid"}, 
-        "__default__"=>{"g4"=>"/tmp/app1-g4.pid", "g5"=>"/tmp/app1-g5.pid"}}, 
-      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}, 
-      "app3"=>{"wow"=>{"e1"=>"/tmp/app3-e1.pid"}}}
-  end
-
-  it "load + 1 app, and pid_file crossed" do
-    subject.load(fixture("dsl/load2.eye")).should include(error: false)
-    subject.load(fixture("dsl/load4.eye")).should include(:error => true, :message => "dublicate pid_files: {\"/tmp/app3-e1.pid\"=>2}")
-
-    subject.short_tree.should == {
-      "app3"=>{"__default__"=>{"e1"=>"/tmp/app3-e1.pid"}}}
-  end
-
-  it "check syntax" do
-    subject.load(fixture("dsl/load2.eye")).should include(error: false)
-    subject.check(fixture("dsl/load4.eye")).should include(:error => true, :message => "dublicate pid_files: {\"/tmp/app3-e1.pid\"=>2}")
-  end
-
-  it "check explain" do
-    res = subject.explain(fixture("dsl/load2.eye"))
-    res[:error].should == false
-    res[:config].is_a?(Hash).should == true
-  end
-
-  it "process and groups disappears" do
-    subject.load(fixture("dsl/load.eye")).should include(error: false)
-    subject.group_by_name('gr1').processes.full_size.should == 2
-
-    subject.load(fixture("dsl/load5.eye")).should include(error: false)
-    sleep 0.5
-
-    group_actors = Celluloid::Actor.all.select{|c| c.class == Eye::Group }
-    process_actors = Celluloid::Actor.all.select{|c| c.class == Eye::Process }
-
-    subject.short_tree.should == {
-      "app1"=>{"gr1"=>{"p1"=>"/tmp/app1-gr1-p1.pid"}},
-      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}}
-
-    group_actors.map{|a| a.name}.sort.should == %w{__default__ gr1}
-    process_actors.map{|a| a.name}.sort.should == %w{p1 z1}
-
-    subject.group_by_name('gr1').processes.full_size.should == 1
-
-    # terminate 1 action
-    subject.process_by_name('p1').terminate
-    subject.info_string.should be_a(String)
-  end
-
-  it "swap groups" do
-    subject.load(fixture("dsl/load.eye")).should include(error: false)
-    subject.load(fixture("dsl/load6.eye")).should include(error: false)
-
-    subject.short_tree.should == {
-      "app1" => {
-        "gr2"=>{"p1"=>"/tmp/app1-gr1-p1.pid", "p2"=>"/tmp/app1-gr1-p2.pid"}, 
-        "gr1"=>{"q3"=>"/tmp/app1-gr2-q3.pid"}, 
-        "__default__"=>{"g4"=>"/tmp/app1-g4.pid", "g5"=>"/tmp/app1-g5.pid"}},
-      "app2"=>{"__default__"=>{"z1"=>"/tmp/app2-z1.pid"}}}
-  end
-
-  it "two configs with same pids (should validate final config)" do
-    subject.load(fixture("dsl/load.eye")).should include(error: false)
-    subject.load(fixture("dsl/load2*.eye")).should == {:error => true, :message=>"dublicate pid_files: {\"/tmp/app3-e1.pid\"=>2}"}    
-  end
-
-  it "two configs with same pids (should validate final config)" do
-    subject.load(fixture("dsl/load.eye")).should include(error: false)
-    subject.load(fixture("dsl/load2.eye")).should include(error: false)
-    subject.load(fixture("dsl/load2_*.eye")).should == {:error => true, :message=>"dublicate pid_files: {\"/tmp/app3-e1.pid\"=>2}"}
-  end
-
-  it "dups of pid_files, but they different with expand" do
-    subject.load(fixture("dsl/load2_dup2.eye")).should include(error: false)
-  end
-
-  it "dups of names but in different scopes" do
-    subject.load(fixture("dsl/load_dup_ex_names.eye")).should include(error: false)
-  end
-
-  describe "configs" do
-    after(:each){ set_glogger }
-
-    it "load logger" do
-      subject.load(fixture("dsl/load_logger.eye")).should include(error: false)
-      Eye::Logger.dev.should == "/tmp/1.log"
-    end
-
-    it "set logger when load multiple configs" do
-      subject.load(fixture("dsl/load_logger{,2}.eye")).should include(error: false)
-      Eye::Logger.dev.should == "/tmp/1.log"
-    end
-
-    it "should corrent load config section" do
-      subject.load(fixture("dsl/configs/{1,2}.eye")).should include(error: false)
-      Eye::Logger.dev.should == "/tmp/a.log"
-      subject.current_config[:config].should == {:logger=>"/tmp/a.log", :http=>{:enable=>true}}
-
-      subject.load(fixture("dsl/configs/3.eye")).should include(error: false)
-      Eye::Logger.dev.should == "/tmp/a.log"
-      subject.current_config[:config].should == {:logger=>"/tmp/a.log", :http=>{:enable=>false}}
-
-      subject.load(fixture("dsl/configs/4.eye")).should include(error: false)
-      Eye::Logger.dev.should == nil
-      subject.current_config[:config].should == {:logger=>'', :http=>{:enable=>false}}
-
-      subject.load(fixture("dsl/configs/2.eye")).should include(error: false)
-      Eye::Logger.dev.should == nil
-      subject.current_config[:config].should == {:logger=>'', :http=>{:enable=>true}}
-    end
-  end
-
-
-  it "load folder" do
-    subject.load(fixture("dsl/load_folder/")).should include(error: false)
-    subject.short_tree.should == {       
-      "app3" => {"wow"=>{"e1"=>"/tmp/app3-e1.pid"}},
-      "app4" => {"__default__"=>{"e2"=>"/tmp/app4-e2.pid"}}
-    }
-  end
-  
-  it "load folder with error" do
-    subject.load(fixture("dsl/load_error_folder/")).should include(error: true)
-  end
-
-  it "load files by mask" do
-    subject.load(fixture("dsl/load_folder/*.eye")).should include(error: false)
-    subject.short_tree.should == {       
-      "app3" => {"wow"=>{"e1"=>"/tmp/app3-e1.pid"}},
-      "app4" => {"__default__"=>{"e2"=>"/tmp/app4-e2.pid"}}
-    }
-  end
-  
-  it "load files by mask with error" do
-    subject.load(fixture("dsl/load_error_folder/*.eye")).should include(error: true)
-  end
-
-  it "load not files with mask" do
-    subject.load(fixture("dsl/load_folder/*.bla")).should include(error: true) 
-  end
-
-  it "bad mask" do
-    subject.load(" asdf asdf afd d").should == {:error => true, :message => "config file ' asdf asdf afd d' not found!"}
-  end
-
-  it "group update it settings" do
-    subject.load(fixture("dsl/load.eye")).should include(error: false)
-    app = subject.application_by_name('app1')
-    gr = subject.group_by_name('gr2')
-    gr.config[:chain].should == {:restart => {:grace=>0.5, :action=>:restart}, :start => {:grace=>0.5, :action=>:start}}
-
-    subject.load(fixture("dsl/load6.eye")).should include(error: false)
-    sleep 1
-
-    gr.config[:chain].should == {:restart => {:grace=>1.0, :action=>:restart}, :start => {:grace=>1.0, :action=>:start}}
-  end
-
-  it "load multiple apps with cross constants" do
-    subject.load(fixture('dsl/subfolder{2,3}.eye')) 
-    subject.process_by_name('e1')[:working_dir].should == '/tmp'
-    subject.process_by_name('e2')[:working_dir].should == 'sub3'
-
-    subject.process_by_name('e3')[:working_dir].should == '/tmp'
-    subject.process_by_name('e4')[:working_dir].should == 'sub2'
-  end
-
-  it "raised load" do
-    subject.load(fixture("dsl/load_error.eye")).should == {error: true, message: "No such file or directory - /asd/fasd/fas/df/asd/fas/df/d"}
-    Eye.logger = $logger_path
-  end
-
-  describe "synchronize groups" do
-    it "correctly schedule monitor for groups and processes" do
-      subject.load(fixture("dsl/load_int.eye")).should include(error: false)
-      sleep 0.5
-
-      p0 = subject.process_by_name 'p0'
-      p1 = subject.process_by_name 'p1'
-      p2 = subject.process_by_name 'p2'
-      gr1 = subject.group_by_name 'gr1'
-      gr_ = subject.group_by_name '__default__'
-
-      p0.schedule_history.states.should == [:monitor]
-      p1.schedule_history.states.should == [:monitor]
-      p2.schedule_history.states.should == [:monitor]
-      gr1.schedule_history.states.should == [:monitor]
-      gr_.schedule_history.states.should == [:monitor]
-
-      subject.load(fixture("dsl/load_int2.eye")).should include(error: false)
-      sleep 0.5
-
-      p1.alive?.should == false
-      p0.alive?.should == false
-
-      p01 = subject.process_by_name 'p0-1'
-      p4 = subject.process_by_name 'p4'
-      p5 = subject.process_by_name 'p5'
-      gr2 = subject.group_by_name 'gr2'
-
-      p2.schedule_history.states.should == [:monitor, :update_config]
-      gr1.schedule_history.states.should == [:monitor, :update_config]
-      gr_.schedule_history.states.should == [:monitor, :update_config]
-
-      p01.schedule_history.states.should == [:monitor]
-      p4.schedule_history.states.should == [:monitor]
-      p5.schedule_history.states.should == [:monitor]
-      gr2.schedule_history.states.should == [:monitor]
-    end
-  end
-
-  describe "load is exclusive" do
-    it "run double in time" do
-      Eye::Control.async.command(:load, fixture("dsl/long_load.eye"))
-      Eye::Control.async.command(:load, fixture("dsl/long_load.eye"))
-      sleep 2.5   
-      should_spend(0, 0.2) do
-        Eye::Control.command(:info).should be_a(String)
-      end
-    end
-
-    it "load with subloads" do
-      silence_warnings{ 
-        Eye::Control.command(:load, fixture("dsl/subfolder2.eye"))
-      }
-      should_spend(0, 0.2) do
-        Eye::Control.command(:info).should be_a(String)
-      end
-    end
-  end
-
-  describe "cleanup configs on delete" do
-    it "load config, delete 1 process, load another config" do
-      subject.load(fixture('dsl/load.eye')) 
-      subject.process_by_name('p1').should be
-
-      subject.command(:delete, "p1"); sleep 0.1
-      subject.process_by_name('p1').should be_nil
-
-      subject.load(fixture('dsl/load2.eye')) 
-      subject.process_by_name('p1').should be_nil      
-    end
-
-    it "load config, delete 1 group, load another config" do
-      subject.load(fixture('dsl/load.eye')) 
-      subject.group_by_name('gr1').should be
-
-      subject.command(:delete, "gr1"); sleep 0.1
-      subject.group_by_name('p1').should be_nil
-
-      subject.load(fixture('dsl/load2.eye')) 
-      subject.group_by_name('gr1').should be_nil      
-    end
-
-    it "load config, then delete app, and load it with changed app-name" do
-      subject.load(fixture('dsl/load3.eye')) 
-      subject.command(:delete, "app3"); sleep 0.1
-      subject.load(fixture('dsl/load4.eye')).should include(error: false)
-    end
-  end
-
-  it "should update only changed apps" do
-    mock(subject).update_or_create_application('app1', is_a(Hash))
-    mock(subject).update_or_create_application('app2', is_a(Hash))
-    subject.load(fixture('dsl/load.eye'))
-
-    mock(subject).update_or_create_application('app3', is_a(Hash))
-    subject.load(fixture('dsl/load2.eye'))    
-
-    mock(subject).update_or_create_application('app3', is_a(Hash))
-    subject.load(fixture('dsl/load3.eye'))
-  end
-
-end

data/spec/controller/races_spec.rb

@@ -1,70 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "Some crazey situations" 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 []
-  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
-    
-    File.delete(File.join(C.sample_dir, "lock1.lock")) rescue nil
-    File.delete(File.join(C.sample_dir, "lock2.lock")) rescue nil
-  end
-
-  it "load another config, with same processes but changed names" do
-    @old_pid1 = @p1.pid
-    @old_pid2 = @p2.pid
-    @old_pid3 = @p3.pid
-  
-    @c.load(fixture("dsl/integration2.eye"))
-    sleep 10
-    
-    # @p1, @p2 recreates
-    # @p3 the same    
-   
-    procs = @c.all_processes 
-    @p1_ = procs.detect{|c| c.name == 'sample1_'}
-    @p2_ = procs.detect{|c| c.name == 'sample2_'}
-    @p3_ = procs.detect{|c| c.name == 'forking'}
-    
-    @p3.object_id.should == @p3_.object_id
-    @p1.alive?.should == false
-    @p1_.alive?.should == true
-
-    @p2.alive?.should == false
-    @p2_.alive?.should == true
-    
-    @p1_.pid.should == @old_pid1
-    @p2_.pid.should == @old_pid2
-    @p3_.pid.should == @old_pid3
-    
-    @p1_.state_name.should == :up
-  end
-
-end

data/spec/controller/stop_on_delete_spec.rb

@@ -1,157 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-describe "StopOnDelete behaviour" do
-  before :each do
-    @c = Eye::Controller.new
-    @c.load(fixture("dsl/integration_sor.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 []
-
-    @old_pid1 = @p1.pid
-    @old_pid2 = @p2.pid
-    @old_pid3 = @p3.pid
-  end
-
-  after :each do
-    @processes = @c.all_processes
-    @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 "delete process => stop process" do
-    @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}
-
-    Eye::System.pid_alive?(@old_pid1).should == false
-    Eye::System.pid_alive?(@old_pid2).should == true
-    Eye::System.pid_alive?(@old_pid3).should == true
-
-    sleep 0.5
-    Eye::System.pid_alive?(@old_pid1).should == false
-  end
-
-  it "delete application => stop group proceses" do
-    @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 == false
-    Eye::System.pid_alive?(@old_pid2).should == false
-    Eye::System.pid_alive?(@old_pid3).should == true
-
-    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 application => stop all proceses" do
-    @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 == false
-    Eye::System.pid_alive?(@old_pid2).should == false
-    Eye::System.pid_alive?(@old_pid3).should == false
-
-    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 "load config when 1 process deleted, it should stopped" do
-    @c.load(fixture("dsl/integration_sor2.eye"))
-    sleep 10
-
-    procs = @c.all_processes 
-    @p1_ = procs.detect{|c| c.name == 'sample1'}
-    @p2_ = procs.detect{|c| c.name == 'sample2'}
-    @p3_ = procs.detect{|c| c.name == 'sample3'}
-
-    @p1_.object_id.should == @p1.object_id
-    @p2_.object_id.should == @p2.object_id
-    @p3_.state_name.should == :up
-
-    @p1_.pid.should == @old_pid1
-    @p2_.pid.should == @old_pid2
-
-    Eye::System.pid_alive?(@old_pid1).should == true
-    Eye::System.pid_alive?(@old_pid2).should == true
-    Eye::System.pid_alive?(@old_pid3).should == false
-
-    @p3.alive?.should == false
-    @c.all_processes.map{|c| c.name}.sort.should == %w{sample1 sample2 sample3}
-  end
-
-  it "load another config, with same processes but changed names" do
-    @c.load(fixture("dsl/integration_sor3.eye"))
-    sleep 15
-    
-    # @p1, @p2 recreates
-    # @p3 the same    
-   
-    procs = @c.all_processes 
-    @p1_ = procs.detect{|c| c.name == 'sample1_'}
-    @p2_ = procs.detect{|c| c.name == 'sample2_'}
-    @p3_ = procs.detect{|c| c.name == 'forking'}
-    
-    @p3.object_id.should == @p3_.object_id
-    @p1.alive?.should == false
-    @p1_.alive?.should == true
-
-    @p2.alive?.should == false
-    @p2_.alive?.should == true
-    
-    @p1_.pid.should_not == @old_pid1
-    @p2_.pid.should_not == @old_pid2
-    @p3_.pid.should == @old_pid3
-    
-    @p1_.state_name.should == :up
-    @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 == false
-    Eye::System.pid_alive?(@old_pid3).should == true
-
-    Eye::System.pid_alive?(@p1_.pid).should == true
-    Eye::System.pid_alive?(@p2_.pid).should == true
-  end
-
-end