eye 0.2.4 → 0.3

data/spec/checker/socket_spec.rb

@@ -1,116 +0,0 @@
-require File.dirname(__FILE__) + '/../spec_helper'
-
-def chsock(cfg = {})
-  Eye::Checker.create(nil, {:type => :socket, :every => 5.seconds, 
-        :times => 1, :addr => 'tcp://127.0.0.1:33231', :send_data => "ping",
-        :expect_data => /pong/, :timeout => 2}.merge(cfg))
-end
-
-def chsockb(cfg = {})
-  Eye::Checker.create(nil, {:type => :socket, :every => 5.seconds, 
-        :times => 1, :addr => 'tcp://127.0.0.1:33232', :protocol => :em_object, :send_data => {}, 
-        :expect_data => /pong/, :timeout => 2}.merge(cfg))
-end
-
-describe "Socket Checker" do
-  %w[ tcp://127.0.0.1:33231 unix:/tmp/em_test_sock_spec].each do |addr|
-    describe "socket: '#{addr}'" do
-      before :each do
-        start_ok_process(C.p4)
-      end
-
-      it "good answer" do
-        c = chsock(:addr => addr)
-        c.get_value.should == {:result => 'pong'}
-        c.check.should == true
-
-        c = chsock(:addr => addr, :expect_data => "pong") # string result ok too
-        c.check.should == true
-      end
-
-      it "timeouted" do
-        c = chsock(:addr => addr, :send_data => "timeout")
-        c.get_value.should == {:exception => "ReadTimeout<2.0>"}
-        c.check.should == false
-      end
-
-      it "bad answer" do
-        c = chsock(:addr => addr, :send_data => "bad")
-        c.get_value.should == {:result => 'what'}
-        c.check.should == false
-
-        c = chsock(:addr => addr, :send_data => "bad", :expect_data => "pong") # string result bad too
-        c.check.should == false
-      end
-
-      it "socket not found" do
-        @process.stop
-        c = chsock(:addr => addr.chop)
-        if addr =~ /tcp/
-          c.get_value.should == {:exception => "Error<Connection refused - connect(2)>"}
-        else
-          c.get_value[:exception].should include("No such file or directory")
-        end
-        c.check.should == false
-      end
-
-      it "check responding without send_data" do
-        c = chsock(:addr => addr, :send_data => nil, :expect_data => nil)
-        c.get_value.should == {:result => :listen}
-        c.check.should == true
-      end
-
-      it "check responding without send_data" do
-        c = chsock(:addr => addr.chop, :send_data => nil, :expect_data => nil)
-        if addr =~ /tcp/
-          c.get_value.should == {:exception => "Error<Connection refused - connect(2)>"}
-        else
-          c.get_value[:exception].should include("No such file or directory")
-        end
-        c.check.should == false
-      end
-    end
-
-  end
-
-  describe "em object protocol" do
-    before :each do
-      start_ok_process(C.p4)
-    end
-
-    it "good answer" do
-      c = chsockb(:send_data => {:command => 'ping'}, :expect_data => 'pong')
-      c.get_value.should == {:result => 'pong'}
-      c.check.should == true
-
-      c = chsockb(:send_data => {:command => 'ping'}, :expect_data => /pong/)
-      c.check.should == true
-
-      c = chsockb(:send_data => {:command => 'ping'}, :expect_data => lambda{|r| r == 'pong'})
-      c.check.should == true
-    end
-    
-    it "should correctly get big message" do
-      c = chsockb(:send_data => {:command => 'big'})
-      res = c.get_value[:result]
-      res.size.should == 9_999_999
-    end
-
-    it "when raised in proc, good? == false" do
-      c = chsockb(:send_data => {:command => 'ping'}, :expect_data => lambda{|r| raise 'haha'})
-      c.check.should == false
-    end
-
-    it "bad answer" do
-      c = chsockb(:send_data => {:command => 'bad'}, :expect_data => 'pong')
-      c.get_value.should == {:result => 'what'}
-      c.check.should == false
-
-      c = chsockb(:send_data => {:command => 'bad'}, :expect_data => /pong/)
-      c.check.should == false
-
-      c = chsockb(:send_data => {:command => 'bad'}, :expect_data => lambda{|r| r == 'pong'})
-      c.check.should == false
-    end
-  end
-end

data/spec/checker_spec.rb

@@ -1,187 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-class Checker1 < Eye::Checker
-
-  def get_value
-    true
-  end
-
-  def good?(value)
-    value
-  end
-end
-
-class Checker2 < Eye::Checker
-  param :bla, [String, Symbol]
-  param :bla2, [String, Symbol], true
-  param :bla3, [String, Symbol], true, "hi"
-  param :bla4, [String, Symbol], false, "hi2"
-  param :bla5, [Fixnum, Float]
-end
-
-describe "Eye::Checker" do
-
-  it "defaults" do
-    @c = Checker1.new(1, {:times => 3})
-    @c.max_tries.should == 3
-    @c.min_tries.should == 3
-  end
-
-  it "defaults" do
-    @c = Checker1.new(1, {:times => [3, 5]})
-    @c.max_tries.should == 5
-    @c.min_tries.should == 3
-  end
-
-  it "defaults" do
-    @c = Checker1.new(1, {})
-    @c.max_tries.should == 1
-    @c.min_tries.should == 1
-  end
-
-  describe "one digit" do
-    before :each do
-      @c = Checker1.new(1, {:times => 3, :bla => 1})
-    end
-
-    it "times 3 from 3" do
-      @c.check.should == true
-      @c.check.should == true
-      @c.check.should == true
-      @c.check.should == true
-    end
-
-    it "times 3 from 3" do
-      stub(@c).get_value{true}
-      @c.check.should == true
-      stub(@c).get_value{false}
-      @c.check.should == true
-      stub(@c).get_value{false}
-      @c.check.should == true
-
-      stub(@c).get_value{true}
-      @c.check.should == true
-    end
-
-    it "times 3 from 3" do
-      stub(@c).get_value{true}
-      @c.check.should == true
-      stub(@c).get_value{false}
-      @c.check.should == true
-      stub(@c).get_value{false}
-      @c.check.should == true
-
-      stub(@c).get_value{false}
-      @c.check.should == false
-    end
-
-  end
-
-  describe "two digits" do
-    before :each do
-      @c = Checker1.new(1, {:times => [2,5], :bla => 1})
-    end
-
-    it "2 from 5" do
-      @c.check.should == true
-      @c.check.should == true
-      @c.check.should == true
-      @c.check.should == true
-      @c.check.should == true
-      @c.check.should == true
-    end
-
-    it "times 2 from 5" do
-      stub(@c).get_value{true}
-      @c.check.should == true
-      stub(@c).get_value{false}
-      @c.check.should == true
-      stub(@c).get_value{true}
-      @c.check.should == true
-
-      stub(@c).get_value{true}
-      @c.check.should == true
-
-      stub(@c).get_value{true}
-      @c.check.should == true
-
-      stub(@c).get_value{true}
-      @c.check.should == true
-    end
-
-
-    it "times 2 from 5" do
-      stub(@c).get_value{true}
-      @c.check.should == true
-      stub(@c).get_value{false}
-      @c.check.should == true
-      stub(@c).get_value{false}
-      @c.check.should == true
-
-      stub(@c).get_value{true}
-      @c.check.should == true
-
-      stub(@c).get_value{true}
-      @c.check.should == false
-
-      stub(@c).get_value{true}
-      @c.check.should == false
-
-      stub(@c).get_value{true}
-      @c.check.should == true
-    end
-  end
-
-  describe "default validates" do
-    it "validate by default" do
-      Checker1.validate({:times => 3})
-    end
-
-    it "validate by default" do
-      expect{ Checker1.validate({:times => "jopa"}) }.to raise_error(Eye::Dsl::Validation::Error)
-    end
-  end
-
-  it "defaults every" do
-    @c = Checker1.new(nil, {:times => 3})
-    @c.every.should == 5
-  end
-
-  it "not defaults every" do
-    @c = Checker1.new(nil, {:times => 3, :every => 10})
-    @c.every.should == 10
-  end
-
-  describe "validates" do
-    it "validate ok" do
-      Checker2.validate({:bla2 => :a111})
-      Checker2.validate({:bla2 => "111"})
-      Checker2.validate({:bla2 => "111", :bla => :bla})
-      Checker2.validate({:bla2 => "111", :bla5 => 10.minutes})
-      Checker2.validate({:bla2 => "111", :bla5 => 15.4.seconds})
-
-      c = Checker2.new(nil, :bla2 => :a111)
-      c.bla.should == nil
-      c.bla2.should == :a111
-      c.bla3.should == 'hi'
-      c.bla4.should == 'hi2'
-
-      c = Checker2.new(nil, :bla2 => :a111, :bla3 => "ho", :bla => 'bla')
-      c.bla.should == 'bla'
-      c.bla2.should == :a111
-      c.bla3.should == 'ho'
-      c.bla4.should == 'hi2'
-    end
-
-    it "validate bad" do
-      expect{ Checker2.validate({}) }.to raise_error
-      expect{ Checker2.validate({:bla => :bla}) }.to raise_error
-      expect{ Checker2.validate({:bla2 => 123}) }.to raise_error
-      expect{ Checker2.validate({:bla2 => :hi, :bla3 => {}}) }.to raise_error
-      expect{ Checker2.validate({:bla => :bla, :bla3 => 1, :bla4 => 2}) }.to raise_error
-      expect{ Checker2.validate({:bla2 => :hi, :bla5 => []}) }.to raise_error
-    end
-
-  end
-
-end

data/spec/child_process/child_process_spec.rb

@@ -1,46 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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