tengine_core 0.5.39 → 1.1.0

data/spec/tengine/core/event_wrapper_spec.rb

@@ -1,35 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'spec_helper'
-
-require 'tengine/event'
-
-describe Tengine::Core::EventWrapper do
-  context "[]でpropertiesの属性にアクセス可能" do
-    before do
-      @event = Tengine::Core::Event.create!(
-        :key => Tengine::Event.uuid_gen.generate,
-        :event_type_name => "foo",
-        :sender_name => "server1",
-        :properties => {
-          :foo => [1,2,3,4],
-          :bar => "BAR"
-        })
-      @event.reload
-    end
-
-    subject do
-      Tengine::Core::EventWrapper.new(@event)
-    end
-
-    it do
-      @event.properties['foo'].should == [1,2,3,4]
-      @event.properties[:foo].should == nil
-      subject.properties['foo'].should == [1,2,3,4]
-      subject.properties[:foo].should == nil
-      subject['foo'].should == [1,2,3,4]
-      subject[:foo].should == [1,2,3,4]
-      subject['bar'].should == "BAR"
-      subject[:bar].should == "BAR"
-    end
-  end
-end

data/spec/tengine/core/handler_path_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-describe Tengine::Core::HandlerPath do
-
-  describe :find_handlers do
-    before do
-      Tengine::Core::Driver.delete_all
-      @d11 = Tengine::Core::Driver.find_or_create_by(name:"driver1", version:"1", enabled:true)
-      @d11h1 = @d11.handlers.find_or_create_by(:event_type_names => ["foo" ], :filepath => "path/to/driver1.rb", :lineno => 5)
-      @d11h2 = @d11.handlers.find_or_create_by(:event_type_names => ["boo" ], :filepath => "path/to/driver1.rb", :lineno => 10)
-      @d11h3 = @d11.handlers.find_or_create_by(:event_type_names => ["blah"], :filepath => "path/to/driver1.rb", :lineno => 15)
-      Tengine::Core::HandlerPath.create(:event_type_name => "foo", :driver => @d11, :handler_id => @d11h1.id)
-      Tengine::Core::HandlerPath.create(:event_type_name => "boo", :driver => @d11, :handler_id => @d11h2.id)
-      Tengine::Core::HandlerPath.create(:event_type_name => "blah", :driver => @d11, :handler_id => @d11h3.id)
-      @d21 = Tengine::Core::Driver.find_or_create_by(name:"driver1", version:"2", enabled:true)
-      @d21h1 = @d21.handlers.find_or_create_by(:event_type_names => ["foo"], :filepath => "path/to/driver1.rb", :lineno => 5)
-      @d21h2 = @d21.handlers.find_or_create_by(:event_type_names => ["boo"], :filepath => "path/to/driver1.rb", :lineno => 12)
-      Tengine::Core::HandlerPath.create(:event_type_name => "foo", :driver => @d21, :handler_id => @d21h1.id)
-      Tengine::Core::HandlerPath.create(:event_type_name => "boo", :driver => @d21, :handler_id => @d21h2.id)
-      @d22 = Tengine::Core::Driver.find_or_create_by(name:"driver2", version:"2", enabled:true)
-      @d22h1 = @d22.handlers.find_or_create_by(:event_type_names => ["foo"], :filepath => "path/to/driver2.rb", :lineno => 20)
-      @d22h2 = @d22.handlers.find_or_create_by(:event_type_names => ["bar"], :filepath => "path/to/driver2.rb", :lineno => 30)
-      Tengine::Core::HandlerPath.create(:event_type_name => "foo", :driver => @d22, :handler_id => @d22h1.id)
-      Tengine::Core::HandlerPath.create(:event_type_name => "bar", :driver => @d22, :handler_id => @d22h2.id)
-      @d23 = Tengine::Core::Driver.find_or_create_by(name:"driver3", version:"2", enabled:false)
-      @d23h1 = @d23.handlers.find_or_create_by(:event_type_names => ["bar"], :filepath => "path/to/driver3.rb", :lineno => 2)
-      @d23h2 = @d23.handlers.find_or_create_by(:event_type_names => ["baz"], :filepath => "path/to/driver3.rb", :lineno => 10)
-      Tengine::Core::HandlerPath.create(:event_type_name => "bar", :driver => @d23, :handler_id => @d23h1.id)
-      Tengine::Core::HandlerPath.create(:event_type_name => "baz", :driver => @d23, :handler_id => @d23h2.id)
-    end
-
-    context "with default_driver_version" do
-      it "should return handlers" do
-        Tengine::Core::HandlerPath.default_driver_version = "2"
-        Tengine::Core::HandlerPath.find_handlers("foo").map(&:id).should == [@d21h1.id, @d22h1.id]
-        Tengine::Core::HandlerPath.find_handlers("boo").map(&:id).should == [@d21h2.id]
-        Tengine::Core::HandlerPath.find_handlers("bar").map(&:id).should == [@d22h2.id]
-        Tengine::Core::HandlerPath.find_handlers("baz").map(&:id).should == []
-        Tengine::Core::HandlerPath.find_handlers("FOO").map(&:id).should == []
-        Tengine::Core::HandlerPath.find_handlers("blah").map(&:id).should == []
-      end
-
-      it "should return old handlers" do
-        Tengine::Core::HandlerPath.default_driver_version = "1"
-        Tengine::Core::HandlerPath.find_handlers("foo").map(&:id).should == [@d11h1.id]
-        Tengine::Core::HandlerPath.find_handlers("boo").map(&:id).should == [@d11h2.id]
-        Tengine::Core::HandlerPath.find_handlers("blah").map(&:id).should == [@d11h3.id]
-        Tengine::Core::HandlerPath.find_handlers("bar").map(&:id).should == []
-        Tengine::Core::HandlerPath.find_handlers("baz").map(&:id).should == []
-      end
-    end
-
-    context "generated handler_paths" do
-      before do
-        Tengine::Core::Driver.delete_all
-        Tengine::Core::HandlerPath.delete_all
-      end
-
-      it "should return handlers for enabled driver" do
-        @driver = Tengine::Core::Driver.new(:name => "driver01", :version => "123", :enabled => true)
-        @handler1 = @driver.handlers.new(:event_type_names => ["event01"],
-          :filepath => "path/to/driver01.rb", :lineno => 8)
-        @driver.save!
-
-        Tengine::Core::HandlerPath.all.count.should == 1
-        Tengine::Core::HandlerPath.default_driver_version = "123"
-        handlers = Tengine::Core::HandlerPath.find_handlers("event01")
-        handlers.count.should == 1
-        handlers.each do |handler|
-          handler.id.should == @handler1.id
-        end
-      end
-
-      it "should return handlers for disabled driver" do
-        @driver = Tengine::Core::Driver.new(:name => "driver01", :version => "123", :enabled => false)
-        @handler1 = @driver.handlers.new(:event_type_names => ["event01"],
-          :filepath => "path/to/driver01.rb", :lineno => 8)
-        @driver.save!
-
-        Tengine::Core::HandlerPath.all.count.should == 1
-        Tengine::Core::HandlerPath.default_driver_version = "123"
-        Tengine::Core::HandlerPath.find_handlers("event01").count.should == 0
-      end
-    end
-  end
-
-end

data/spec/tengine/core/handler_spec.rb

@@ -1,190 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'spec_helper'
-
-describe Tengine::Core::Handler do
-  valid_attributes1 = {
-    :filepath => "path/to/driver.rb",
-    :lineno => 100,
-  }.freeze
-
-  context "filepathとlinenoは必須" do
-    it "正常系" do
-      driver1 = Tengine::Core::Handler.new(valid_attributes1)
-      driver1.valid?.should == true
-    end
-
-    [:filepath, :lineno].each do |key|
-      it "#{key}なし" do
-        attrs = valid_attributes1.dup
-        attrs.delete(key)
-        driver1 = Tengine::Core::Handler.new(attrs)
-        driver1.valid?.should == false
-      end
-    end
-  end
-
-#   context :process_event do
-#     before do
-#       @driver = Tengine::Core::Driver.new
-#       @handler = Tengine::Core::Handler.new(:driver => @driver)
-#     end
-
-#     it "マッチするかどうかと関係なくブロックが呼び出されます" do
-#       mock_dsl_context = mock(:dsl_context)
-#       mock_kernel = mock(:kernel)
-#       mock_event = mock(:event)
-#       mock_caller = mock(:caller)
-#       mock_block = nil
-#       mock_caller.instance_eval do
-#         mock_block = lambda{}
-#       end
-#       mock_event.stub(:kernel).and_return(mock_kernel)
-#       mock_kernel.stub(:dsl_context).and_return(mock_dsl_context)
-#       mock_dsl_context.stub(:__block_for__).and_return(mock_block)
-#       # @handler.should_receive(:instance_eval).with(&mock_block)
-#       mock_caller.should_receive(:__safety_driver__).and_yield
-#       mock_caller.should_receive(:__safety_event__).and_yield
-#       mock_caller.should_receive(:instance_eval)
-#       @handler.process_event(mock_event, &mock_block)
-#     end
-#   end
-
-  describe :match? do
-    context "without session" do
-      # it "by source_name"
-      # it "by sender_name"
-      # it "by occurred_at"
-    end
-
-    context "with session" do
-      context "foo & bar" do
-        before do
-          Tengine::Core::Driver.delete_all
-          Tengine::Core::Session.delete_all
-          @driver1 = Tengine::Core::Driver.new(:name => "driver1", :version => "123")
-          @handler = @driver1.handlers.new(:event_type_names => [:foo, :bar],
-            :filepath => "path/to/driver.rb",
-            :lineno => 11,
-            :filter => {
-              'method' => :and,
-              'children' => [
-                { 'pattern' => 'foo', 'method' => :find_or_mark_in_session },
-                { 'pattern' => 'bar', 'method' => :find_or_mark_in_session },
-              ]
-            })
-          @driver1.save!
-          @handler
-        end
-        subject{ @handler }
-
-        it "最初にfooが受信したらセッションに記録してfalse" do
-          event_foo = FactoryGirl.create(:"tengine/core/event", :event_type_name => "foo")
-          subject.match?(event_foo).should == false
-          @driver1.session.system_properties.should == {'mark_foo' => true}
-        end
-
-        it "最初にbarが受信したらセッションに記録してfalse" do
-          # 実装がall?などを使って全てのフィルタを評価しない場合は失敗することがあります。
-          event_bar = FactoryGirl.create(:"tengine/core/event", :event_type_name => "bar")
-          subject.match?(event_bar).should == false
-          @driver1.session.system_properties.should == {'mark_bar' => true}
-        end
-
-        context "一度fooを受信した場合" do
-          before do
-            session = @driver1.session
-            session.system_properties = {'mark_foo' => true}
-            session.save!
-          end
-
-          it "再度fooが来るとセッションは変更なくfalse" do
-            event_foo = FactoryGirl.create(:"tengine/core/event", :event_type_name => "foo")
-            subject.match?(event_foo).should == false
-            @driver1.reload
-            @driver1.session.system_properties.should == {'mark_foo' => true}
-          end
-
-          it "barが来るとセッションを変更してtrue" do
-            event_bar = FactoryGirl.create(:"tengine/core/event", :event_type_name => "bar")
-            subject.match?(event_bar).should == true
-            @driver1.reload
-            @driver1.session.system_properties.should == {'mark_foo' => true, 'mark_bar' => true}
-          end
-        end
-
-        context "一度barを受信した場合" do
-          before do
-            session = @driver1.session
-            session.system_properties = {'mark_bar' => true}
-            session.save!
-          end
-
-          it "fooが来るとセッションを変更してtrue" do
-            event_foo = FactoryGirl.create(:"tengine/core/event", :event_type_name => "foo")
-            subject.match?(event_foo).should == true
-            @driver1.reload
-            @driver1.session.system_properties.should == {'mark_foo' => true, 'mark_bar' => true}
-          end
-        end
-
-
-      end
-
-    end
-
-  end
-
-
-  describe 'filter persistence' do
-    before do
-      Tengine::Core::Driver.delete_all
-      @driver1 = Tengine::Core::Driver.new(:name => "driver1", :version => "123")
-    end
-
-    it "デフォルトでは空のHash" do
-      @driver1.handlers.new(:event_type_names => [:foo, :bar],
-        :filepath => "path/to/driver.rb", :lineno => 8)
-      @driver1.save!
-      loaded = Tengine::Core::Driver.find(@driver1.id)
-      handler1 = loaded.handlers.first
-      handler1.filter.should == {}
-    end
-
-    it "はネストしたフィルタの情報を保持できる" do
-      expected_hash = {
-          :method => :or,
-          :children => [
-            {
-              :method => :and,
-              :children => [
-                { :pattern => 'foo', :method => :find_or_mark_in_session },
-                { :pattern => 'bar', :method => :find_or_mark_in_session },
-              ]
-            },
-            { :method => :equal, :pattern => "baz"}
-          ]
-        }
-      @driver1.handlers.new(:event_type_names => [:foo, :bar],
-        :filepath => "path/to/driver.rb", :lineno => 8,
-        :filter => expected_hash)
-      @driver1.save!
-      loaded = Tengine::Core::Driver.find(@driver1.id)
-      handler1 = loaded.handlers.first
-      # mongoの制約でSymbolのキーは文字列に変換される。
-      handler1.filter.should == {
-          'method' => :or,
-          'children' => [
-            {
-              'method' => :and,
-              'children' => [
-                { 'pattern' => 'foo', 'method' => :find_or_mark_in_session },
-                { 'pattern' => 'bar', 'method' => :find_or_mark_in_session },
-              ]
-            },
-            { 'method' => :equal, 'pattern' => "baz"}
-          ]
-        }
-    end
-  end
-
-end

data/spec/tengine/core/heartbeat_watcher_spec.rb

@@ -1,131 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'spec_helper'
-require 'amqp'
-
-require_relative '../../../lib/tengine/core/heartbeat_watcher'
-require 'tengine/mq/suite'
-
-describe Tengine::Core::HeartbeatWatcher do
-  before do
-    Tengine::Core::Event.delete_all
-    @uuid = UUID.new
-  end
-
-  subject do
-    Tengine::Core::HeartbeatWatcher.new(%w[--heartbeat-hbw-interval=30])
-  end
-
-  describe "#search_for_invalid_heartbeat" do
-
-    before do
-      @fixtures = Array.new
-      @fixtures << Tengine::Core::Event.new(key: @uuid.generate, event_type_name: "job.heartbeat.tengine", occurred_at: 1.day.ago)
-      @fixtures << Tengine::Core::Event.new(key: @uuid.generate, event_type_name: "job.heartbeat.tengine", occurred_at: 1.second.ago)
-      @fixtures.each {|i| i.save! }
-    end
-
-    it "古いものを検索してくる" do
-      set = []
-      EM.run do
-        subject.search_for_invalid_heartbeat do |i|
-          set << i
-        end
-        EM.add_timer 0.1 do EM.stop end
-      end
-
-      set.should include(@fixtures[0])
-      set.should_not include(@fixtures[1])
-    end
-  end
-
-  describe "#search_for_invalid_heartbeat, kind_of" do
-
-    before do
-      @fixtures = Array.new
-      @fixtures << Tengine::Core::Event.new(key: "job1", event_type_name: "job.heartbeat.tengine", occurred_at: 1.day.ago)
-      @fixtures << Tengine::Core::Event.new(key: "job2", event_type_name: "job.heartbeat.tengine", occurred_at: 1.second.ago)
-      @fixtures << Tengine::Core::Event.new(key: "cor1", event_type_name: "core.heartbeat.tengine", occurred_at: 1.day.ago)
-      @fixtures << Tengine::Core::Event.new(key: "cor2", event_type_name: "core.heartbeat.tengine", occurred_at: 10.second.ago)
-      @fixtures << Tengine::Core::Event.new(key: "hbw1", event_type_name: "hbw.heartbeat.tengine", occurred_at: 1.day.ago)
-      @fixtures << Tengine::Core::Event.new(key: "hbw2", event_type_name: "hbw.heartbeat.tengine", occurred_at: 1.second.ago)
-      @fixtures << Tengine::Core::Event.new(key: "rsw1", event_type_name: "resourcew.heartbeat.tengine", occurred_at: 1.day.ago)
-      @fixtures << Tengine::Core::Event.new(key: "rsw2", event_type_name: "resourcew.heartbeat.tengine", occurred_at: 10.second.ago)
-      @fixtures << Tengine::Core::Event.new(key: "atd1", event_type_name: "atd.heartbeat.tengine", occurred_at: 1.day.ago)
-      @fixtures << Tengine::Core::Event.new(key: "atd2", event_type_name: "atd.heartbeat.tengine", occurred_at: 10.second.ago)
-      @fixtures << Tengine::Core::Event.new(key: "hog1", event_type_name: "hoge.heartbeat.tengine", occurred_at: 1.day.ago)
-      @fixtures << Tengine::Core::Event.new(key: "hog2", event_type_name: "hoge.heartbeat.tengine", occurred_at: 10.second.ago)
-      @fixtures.each {|i| i.save! }
-    end
-
-    it "古い job,core,hbw,resourcew,atd を検索してくる" do
-      EM.run do
-        subject.search_for_invalid_heartbeat do |i|
-          (i.key =~ /job1|cor1|hbw1|rsw1|atd1/).should be_true
-          (i.key =~ /job2|cor2|hbw2|rsw2|atd2|hog1|hog2/).should be_false
-        end
-        EM.add_timer 0.1 do EM.stop end
-      end
-    end
-  end
-
-  describe "#send_last_event" do
-    it "finished.process.hbw.tengineの発火" do
-      sender = mock(:sender)
-      subject.stub(:sender).and_return(sender)
-      sender.should_receive(:fire).with("finished.process.hbw.tengine", an_instance_of(Hash))
-      sender.should_receive(:stop)
-      subject.send_last_event
-    end
-  end
-
-  describe "#send_periodic_event" do
-    it "hbw.heartbeat.tengineの発火" do
-      sender = mock(:sender)
-      subject.stub(:sender).and_return(sender)
-      sender.should_receive(:fire).with("hbw.heartbeat.tengine", an_instance_of(Hash))
-      sender.stub(:fire).with("finished.process.hbw.tengine", an_instance_of(Hash)) # 来るかも
-      subject.send_periodic_event
-    end
-  end
-
-  describe "#send_invalidate_event" do
-    it "引数のイベントのtypeを書き換えて、他は同じで発火" do
-      e0 = Tengine::Core::Event.new(key: @uuid.generate, event_type_name: "job.heartbeat.tengine", occurred_at: 1.day.ago)
-      sender = mock(:sender)
-      subject.stub(:sender).and_return(sender)
-      sender.should_receive(:fire).with(an_instance_of(Tengine::Event), an_instance_of(Hash)) do |e1, h|
-        e1.event_type_name.should == "foobar"
-        e1.occurred_at.should == e0.occurred_at
-        e1.key.should == e0.key
-      end
-
-      subject.send_invalidate_event "foobar", e0
-    end
-  end
-
-  describe "#sender" do
-    before do
-      conn = mock(:connection)
-      conn.stub(:on_tcp_connection_loss)
-      conn.stub(:after_recovery)
-      conn.stub(:on_closed)
-      AMQP.stub(:connect).with(an_instance_of(Hash)).and_return(conn)
-    end
-    subject { Tengine::Core::HeartbeatWatcher.new([]).sender }
-    it { should be_kind_of(Tengine::Event::Sender) }
-  end
-
-  describe "#run" do
-    it "各種timerを登録する" do
-      EM.stub(:run).and_yield
-      Daemons.stub(:run_proc).with(anything, anything).and_yield
-      EM.should_receive(:add_periodic_timer).exactly(2).times
-      Tengine::Core::MethodTraceable.stub(:disabled=)
-      sender = mock(:sender)
-      sender.stub(:wait_for_connection).and_yield
-      subject.stub(:sender).and_return(sender)
-      subject.instance_eval { @config }.stub(:setup_loggers)
-      subject.run __FILE__
-    end
-  end
-end

data/spec/tengine/core/io_to_logger_spec.rb

@@ -1,30 +0,0 @@
-
-
-
-# -*- coding: utf-8 -*-
-require 'spec_helper'
-
-require 'stringio'
-
-describe Tengine::Core::IoToLogger do
-
-  context "redirect from io to logger" do
-    before do
-      @io = StringIO.new
-      @logger = Logger.new(@io)
-      @logger.level = Logger::INFO
-    end
-    subject{ Tengine::Core::IoToLogger.new(@logger) }
-    it "should provide puts method" do
-      subject.puts("foo")
-      @io.rewind
-      @io.readlines.should == ["foo\n"]
-    end
-    it "should provide write method" do
-      subject.write("foo")
-      @io.rewind
-      @io.readlines.should == ["foo\n"]
-    end
-  end
-
-end