tengine_event 0.4.6

data/lib/tengine/mq.rb

@@ -0,0 +1,5 @@
+require 'tengine_event'
+
+module Tengine::Mq
+  autoload :Suite, "tengine/mq/suite"
+end

data/lib/tengine/null_logger.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+require 'tengine_event'
+
+# NullLoggerはロガーのNull Objectです。
+# Loggerと同じインタフェースを持ちますが何も動作しません。
+class Tengine::NullLogger
+  %w[debug info warn error fatal log].each do |log_level|
+    class_eval("def #{log_level}(*args); end")
+  end
+end

data/lib/tengine_event.rb

@@ -0,0 +1,13 @@
+module Tengine
+  autoload :Event     , 'tengine/event'
+  autoload :Mq        , 'tengine/mq'
+  autoload :NullLogger, 'tengine/null_logger'
+
+  class << self
+    def logger
+      @logger ||= NullLogger.new # ::Logger.new(STDOUT)
+    end
+    attr_writer :logger
+  end
+
+end

data/spec/.gitignore

@@ -0,0 +1 @@
+/mq_config.yml

data/spec/mq_config.yml.example

@@ -0,0 +1,13 @@
+connection:
+  host: 'localhost'
+  port: 5672
+  # vhost:
+  # user:
+  # pass:
+exchange:
+  name: 'tengine_event_test_exchange'
+  type: 'direct'
+  durable: true
+queue:
+  name: 'tengine_event_test_queue'
+  durable: true

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'tengine_event'
+
+require 'simplecov'
+SimpleCov.start if ENV["COVERAGE"]
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/spec/tengine/event/model_notifiable_spec.rb

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "Tengine::Event::ModelNotifiable" do
+
+  module TengineTest
+    class MockModel
+      attr_accessor :attributes, :changes
+      def initialize(attributes)
+        @attributes = attributes
+      end
+    end
+  end
+
+  class TestModelNotifier
+    include Tengine::Event::ModelNotifiable
+
+    def initialize(sender)
+      @sender= sender
+    end
+
+    def event_sender
+      @sender
+    end
+  end
+
+  context "ActiveModelなどのObserverでそれぞれメソッドが呼び出されます" do
+    before do
+      @mock_sender = mock(:sender)
+      @notifier = TestModelNotifier.new(@mock_sender)
+    end
+
+    it "after_create" do
+      @mock_sender.should_receive(:fire).with("TengineTest::MockModel.created.TestModelNotifier", {
+          :level_key => :info,
+          :properties => {
+            :class_name => "TengineTest::MockModel",
+            :attributes => {
+              :name => "GariGariKun",
+              :price => 50
+           }
+          }
+        })
+      @notifier.after_create(TengineTest::MockModel.new(:name => "GariGariKun", :price => 50))
+    end
+
+    it "after_update" do
+      @mock_sender.should_receive(:fire).with("TengineTest::MockModel.updated.TestModelNotifier", {
+          :level_key => :info,
+          :properties => {
+            :class_name => "TengineTest::MockModel",
+            :attributes => {
+              :name => "GariGariKun",
+              :price => 60
+            },
+            :changes => {"price" => [50, 60]},
+           }
+        })
+      model = TengineTest::MockModel.new(:name => "GariGariKun", :price => 60)
+      model.changes = {"price" => [50, 60]}
+      @notifier.after_update(model)
+    end
+
+    it "after_destroy" do
+      @mock_sender.should_receive(:fire).with("TengineTest::MockModel.destroyed.TestModelNotifier", {
+          :level_key => :info,
+          :properties => {
+            :class_name => "TengineTest::MockModel",
+            :attributes => {
+              :name => "GariGariKun",
+              :price => 60
+            }
+          }
+        })
+      @notifier.after_destroy(TengineTest::MockModel.new(:name => "GariGariKun", :price => 60))
+    end
+
+  end
+
+end

data/spec/tengine/event/sender_spec.rb

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../../spec_helper', __FILE__)
+
+# fire の機能面(何を送信するか等)に関してはmq/suiteに記載済み
+describe "Tengine::Event::Sender" do
+  describe "#initialize" do
+    context "no args" do
+      subject{ Tengine::Event::Sender.new.mq_suite }
+      it { should_not be_nil }
+      it { should be_kind_of Tengine::Mq::Suite }
+    end
+
+    context "with options" do
+      subject{ Tengine::Event::Sender.new(:exchange => {:name => "another_exhange"}).mq_suite.config[:exchange][:name] }
+      it { should == "another_exhange" }
+    end
+
+    context "with mq_suite" do
+      before{ @mq_suite = Tengine::Mq::Suite.new }
+      subject{ Tengine::Event::Sender.new(@mq_suite).mq_suite }
+      it { should == @mq_suite }
+    end
+
+    context "with mq_suite and options" do
+      before do
+        @mq_suite = Tengine::Mq::Suite.new
+        @logger = mock(:logger)
+      end
+      subject { Tengine::Event::Sender.new(@mq_suite, :logger => @logger) }
+      its (:mq_suite) { should == @mq_suite }
+      its (:logger) { should == @logger }
+    end
+  end
+
+  describe "#stop" do
+    before { @mq_suite = Tengine::Mq::Suite.new }
+    subject { Tengine::Event::Sender.new(@mq_suite) }
+
+    it "stops suite" do
+      @mq_suite.should_receive :stop
+      subject.stop
+    end
+
+    it "calls the given block (if any) afterwards" do
+      @mq_suite.should_receive(:stop).and_yield
+      block_called = false
+      subject.stop { block_called = true }
+      block_called.should == true
+    end
+  end
+
+  describe "#pending_events" do
+    before do
+      @mq_suite = Tengine::Mq::Suite.new
+      @event = Tengine::Event.new
+      @mq_suite.stub(:pending_events_for).with(an_instance_of(Tengine::Event::Sender)).and_return([@event])
+    end
+    subject { Tengine::Event::Sender.new(@mq_suite).pending_events }
+
+    it { should be_kind_of Array }
+    it { should have(1).events }
+    it { should include(@event) }
+  end
+
+  describe "#wait_for_connection" do
+    it "does nothing" do
+      expect {
+        Tengine::Event::Sender.new.wait_for_connection {  }
+      }.to_not raise_error
+    end
+  end
+
+  describe "#fire" do
+    before do
+      @event = Tengine::Event.new
+      @mq_suite = Tengine::Mq::Suite.new
+      @mq_suite.stub(:fire).
+        with(an_instance_of(Tengine::Event::Sender),
+             an_instance_of(Tengine::Event),
+             an_instance_of(Hash),
+             an_instance_of(Proc)) {
+        |q, w, e, r|
+        r.yield
+      }
+      @mq_suite.stub(:fire).
+        with(an_instance_of(Tengine::Event::Sender),
+             an_instance_of(Tengine::Event),
+             an_instance_of(Hash),
+             an_instance_of(NilClass))
+    end
+
+    context "mandatory one arg" do
+      it { expect { Tengine::Event::Sender.new(@mq_suite).fire }.to raise_exception(ArgumentError) }
+    end
+
+    context "one, string arg" do
+      subject { Tengine::Event::Sender.new(@mq_suite).fire("foo") }
+      it { should be_kind_of(Tengine::Event) }
+      its (:event_type_name) { should == "foo" }
+    end
+
+    context "one, event arg" do
+      subject { Tengine::Event::Sender.new(@mq_suite).fire(@event) }
+      it { should be_kind_of(Tengine::Event) }
+      it { should == @event }
+    end
+
+    context "event arg + option" do
+      subject { Tengine::Event::Sender.new(@mq_suite).fire(@event, :keep_connection => true) }
+      it { should == @event }
+    end
+
+    context "block argument" do
+      before { @event = Tengine::Event.new }
+      it "is called" do
+        block_called = false
+        Tengine::Event::Sender.new(@mq_suite).fire(@event) do
+          block_called = true
+        end
+        block_called.should == true
+      end
+    end
+  end
+end

data/spec/tengine/event_spec.rb

@@ -0,0 +1,397 @@
+# -*- coding: utf-8 -*-
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'amqp'
+require 'time'
+
+describe "Tengine::Event" do
+  expected_source_name = "this_server1/12345"
+
+  before do
+    Tengine::Event.stub!(:host_name).and_return("this_server1")
+    Process.stub!(:pid).and_return(12345)
+  end
+
+  # hack!
+  after :each do
+    EM.instance_eval do
+      @next_tick_mutex.synchronize do
+        @next_tick_queue = nil
+      end
+    end
+  end
+
+  describe :new_object do
+    context "without config" do
+      before do
+        Tengine::Event.config = {}
+        @now = Time.now
+        Time.stub!(:now).and_return(@now)
+      end
+
+      it{ Tengine::Event.default_source_name.should == expected_source_name }
+      it{ Tengine::Event.default_sender_name.should == expected_source_name }
+      it{ Tengine::Event.default_level.should == 2 }
+
+      subject{ Tengine::Event.new }
+      it{ subject.should be_a(Tengine::Event) }
+      its(:key){ should =~ /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/ }
+      its(:event_type_name){ should be_nil }
+      its(:source_name){ should == expected_source_name}
+      its(:occurred_at){ should == @now.utc }
+      its(:level){ should == 2}
+      its(:level_key){ should == :info}
+      its(:sender_name){ should == expected_source_name }
+      its(:properties){ should be_a(Hash) }
+      its(:properties){ should be_empty }
+      it {
+        attrs = subject.attributes
+        attrs.should be_a(Hash)
+        attrs.delete(:key).should_not be_nil
+        attrs.should == {
+          :occurred_at => @now.utc,
+          :level=>2,
+          :source_name => expected_source_name,
+          :sender_name => expected_source_name,
+        }
+      }
+      it {
+        hash = JSON.parse(subject.to_json)
+        hash.should be_a(Hash)
+        hash.delete('key').should =~ /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/
+        hash.should == {
+          'occurred_at' => @now.utc.iso8601,
+          "level" => 2,
+          'source_name' => expected_source_name,
+          'sender_name' => expected_source_name,
+        }
+      }
+    end
+
+    context "with config" do
+      before do
+        Tengine::Event.config = {
+          :default_source_name => "event_source1",
+          :default_sender_name => "sender1",
+          :default_level_key => :warn
+        }
+        @now = Time.now
+        Time.stub!(:now).and_return(@now)
+      end
+      after do
+        Tengine::Event.config = {}
+      end
+
+      it{ Tengine::Event.default_source_name.should == "event_source1" }
+      it{ Tengine::Event.default_sender_name.should == "sender1" }
+      it{ Tengine::Event.default_level.should == 3 }
+
+      subject{ Tengine::Event.new }
+      it{ subject.should be_a(Tengine::Event) }
+      its(:key){ should =~ /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/ }
+      its(:event_type_name){ should be_nil }
+      its(:source_name){ should == "event_source1"}
+      its(:occurred_at){ should == @now.utc }
+      its(:level){ should == 3}
+      its(:level_key){ should == :warn}
+      its(:sender_name){ should == "sender1" }
+      its(:properties){ should be_a(Hash) }
+      its(:properties){ should be_empty }
+      it {
+        attrs = subject.attributes
+        attrs.should be_a(Hash)
+        attrs.delete(:key).should_not be_nil
+        attrs.should == {
+          :occurred_at => @now.utc,
+          :level=>3,
+          :source_name => "event_source1",
+          :sender_name => "sender1",
+        }
+      }
+      it {
+        hash = JSON.parse(subject.to_json)
+        hash.should be_a(Hash)
+        hash.delete('key').should =~ /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/
+        hash.should == {
+          'occurred_at' => @now.utc.iso8601,
+          'level'=>3,
+          'source_name' => "event_source1",
+          'sender_name' => "sender1",
+        }
+      }
+    end
+
+  end
+
+  describe :new_object_with_attrs do
+    subject{ Tengine::Event.new(
+        :event_type_name => :foo,
+        :key => "hoge",
+        'source_name' => "server1",
+        :occurred_at => Time.utc(2011,8,11,12,0),
+        :level_key => 'error',
+        'sender_name' => "server2",
+        :properties => {:bar => "ABC", :baz => 999}
+        )}
+    it{ subject.should be_a(Tengine::Event) }
+    its(:key){ should == "hoge" }
+    its(:event_type_name){ should == "foo" }
+    its(:source_name){ should == "server1" }
+    its(:occurred_at){ should == Time.utc(2011,8,11,12,0) }
+    its(:level){ should == 4}
+    its(:level_key){ should == :error}
+    its(:sender_name){ should == "server2" }
+    its(:properties){ should == {'bar' => "ABC", 'baz' => 999}}
+    it {
+      attrs = subject.attributes
+      attrs.should == {
+        :event_type_name => 'foo',
+        :key => "hoge",
+        :source_name => "server1",
+        :occurred_at => Time.utc(2011,8,11,12,0),
+        :level => 4,
+        :sender_name => "server2",
+        :properties => {'bar' => "ABC", 'baz' => 999}
+      }
+    }
+    it {
+      hash = JSON.parse(subject.to_json)
+      hash.should be_a(Hash)
+      hash.should == {
+        "level"=>4,
+        'event_type_name' => 'foo',
+        'key' => "hoge",
+        'source_name' => "server1",
+        'occurred_at' => "2011-08-11T12:00:00Z", # Timeオブジェクトは文字列に変換されます
+        'sender_name' => "server2",
+        'properties' => {'bar' => "ABC", 'baz' => 999}
+      }
+    }
+  end
+
+  describe 'occurred_at with local_time should convert to UTC' do
+    subject{ Tengine::Event.new(
+        :occurred_at => Time.parse("2011-08-31 12:00:00 +0900"),
+        :key => 'hoge'
+        )}
+    it{ subject.should be_a(Tengine::Event) }
+    its(:occurred_at){ should == Time.utc(2011,8,31,3,0) }
+    its(:occurred_at){ should be_utc }
+    it {
+      hash = JSON.parse(subject.to_json)
+      hash.should be_a(Hash)
+      hash.should == {
+        "level"=>2,
+        'key' => "hoge",
+        'occurred_at' => "2011-08-31T03:00:00Z", # Timeオブジェクトは文字列に変換されます
+        'source_name' => "this_server1/12345",
+        'sender_name' => "this_server1/12345",
+      }
+    }
+  end
+
+  it 'attrs_for_new must be Hash' do
+    expect{
+      Tengine::Event.new("{foo: 1, bar: 2}")
+    }.to raise_error(ArgumentError, /attrs must be a Hash but was/)
+  end
+
+
+  describe :occurred_at do
+    context "valid nil" do
+      subject{ Tengine::Event.new(:occurred_at => nil) }
+      it do
+        subject.occurred_at = nil
+        subject.occurred_at.should == nil
+      end
+    end
+    context "valid String" do
+      subject{ Tengine::Event.new(:occurred_at => "2011-08-31 12:00:00 +0900") }
+      its(:occurred_at){ should be_a(Time); should == Time.utc(2011, 8, 31, 3)}
+    end
+    it "invalid Class: Range" do
+      expect{
+        Tengine::Event.new(:occurred_at => (1..3))
+      }.to raise_error(ArgumentError)
+    end
+  end
+  it 'occurred_at must be Time' do
+    expect{
+      Tengine::Event.new(:occurred_at => "invalid time string")
+    }.to raise_error(ArgumentError, /no time information/)
+  end
+
+  describe :level do
+    {
+      0 => :gr_heartbeat,
+      1 => :debug,
+      2 => :info,
+      3 => :warn,
+      4 => :error,
+      5 => :fatal,
+    }.each do |level, level_key|
+      context "set by level" do
+        subject{ Tengine::Event.new(:level => level) }
+        its(:level_key){ should == level_key}
+      end
+      context "set Symbol by level_key" do
+        subject{ Tengine::Event.new(:level_key => level_key.to_sym) }
+        its(:level){ should == level}
+        its(:level_key){ should == level_key.to_sym}
+      end
+      context "set String by level_key" do
+        subject{ Tengine::Event.new(:level_key => level_key.to_s) }
+        its(:level){ should == level}
+        its(:level_key){ should == level_key.to_sym}
+      end
+    end
+  end
+
+  describe :properties do
+    subject{ Tengine::Event.new }
+    it "valid usage" do
+      subject.properties.should == {}
+      subject.properties = {:foo => 123}
+      subject.properties.should == {'foo' => 123}
+      subject.properties = {:bar => 456}
+      subject.properties.should == {'bar' => 456}
+    end
+    it "assign nil" do
+      subject.properties = nil
+      subject.properties.should == {}
+    end
+  end
+
+
+  describe :fire do
+    before do
+      Tengine::Event.config = {
+        :connection => {"foo" => "aaa"},
+        :exchange => {'name' => "exchange1", 'type' => 'direct', 'durable' => true, 'publish' => {'persistent' => true}},
+        :queue => {'name' => "queue1", 'durable' => true},
+      }
+      @mock_connection = mock(:connection)
+      @mock_channel = mock(:channel)
+      @mock_exchange = mock(:exchange)
+      AMQP.should_receive(:connect).with(an_instance_of(Hash)).and_yield(@mock_connection).and_return(@mock_connection)
+      @mock_connection.stub(:connected?).and_return(true)
+      @mock_connection.stub(:disconnect).and_yield
+      @mock_connection.stub(:server_capabilities).and_return(nil)
+      AMQP::Channel.should_receive(:new).with(@mock_connection, an_instance_of(Fixnum), an_instance_of(Hash)).and_yield(@mock_channel).and_return(@mock_channel)
+      @mock_channel.stub(:publisher_index).and_return(nil)
+      AMQP::Exchange.should_receive(:new).with(@mock_channel, :direct, "exchange1",
+        :passive=>false, :durable=>true, :auto_delete=>false, :internal=>false, :nowait=>false).and_yield(@mock_exchange).and_return(@mock_exchange)
+      @mock_channel.stub(:close)
+    end
+
+    it "JSON形式にserializeしてexchangeにpublishする" do
+      expected_event = Tengine::Event.new(:event_type_name => :foo, :key => "uniq_key")
+      @mock_exchange.should_receive(:publish).with(expected_event.to_json, :persistent => true, :content_type => "application/json")
+      EM.run do
+        Tengine::Event.fire(:foo, :key => "uniq_key")
+        EM.add_timer(0.1) do
+          EM.next_tick do
+            EM.stop
+          end
+        end
+      end
+    end
+  end
+
+
+  describe :parse do
+    context "can parse valid json object" do
+      subject do
+        source = Tengine::Event.new(
+          :event_type_name => :foo,
+          :key => "hoge",
+          'source_name' => "server1",
+          :occurred_at => Time.utc(2011,8,11,12,0),
+          :level_key => 'error',
+          'sender_name' => "server2",
+          :properties => {:bar => "ABC", :baz => 999}
+          )
+        Tengine::Event.parse(source.to_json)
+      end
+      its(:key){ should == "hoge" }
+      its(:event_type_name){ should == "foo" }
+      its(:source_name){ should == "server1" }
+      its(:occurred_at){ should == Time.utc(2011,8,11,12,0) }
+      its(:level){ should == 4}
+      its(:level_key){ should == :error}
+      its(:sender_name){ should == "server2" }
+      its(:properties){ should == {'bar' => "ABC", 'baz' => 999}}
+    end
+
+    context "can parse valid json array" do
+      before do
+        source1 = Tengine::Event.new(
+          :event_type_name => :foo,
+          :key => "hoge1",
+          'source_name' => "server1",
+          :occurred_at => Time.utc(2011,8,11,12,0),
+          :level_key => 'error',
+          'sender_name' => "server2",
+          :properties => {:bar => "ABC", :baz => 999}
+          )
+        source2 = Tengine::Event.new(
+          :event_type_name => :bar,
+          :key => "hoge2",
+          'source_name' => "server3",
+          :occurred_at => Time.utc(2011,9,24,15,50),
+          :level_key => 'warn',
+          'sender_name' => "server4",
+          :properties => {:bar => "DEF", :baz => 777}
+          )
+        @parsed = Tengine::Event.parse([source1, source2].to_json)
+      end
+
+      context "first" do
+        subject{ @parsed.first }
+        its(:key){ should == "hoge1" }
+        its(:event_type_name){ should == "foo" }
+        its(:source_name){ should == "server1" }
+        its(:occurred_at){ should == Time.utc(2011,8,11,12,0) }
+        its(:level){ should == 4}
+        its(:level_key){ should == :error}
+        its(:sender_name){ should == "server2" }
+        its(:properties){ should == {'bar' => "ABC", 'baz' => 999}}
+      end
+
+      context "last" do
+        subject{ @parsed.last }
+        its(:key){ should == "hoge2" }
+        its(:event_type_name){ should == "bar" }
+        its(:source_name){ should == "server3" }
+        its(:occurred_at){ should == Time.utc(2011,9,24,15,50) }
+        its(:level){ should == 3}
+        its(:level_key){ should == :warn}
+        its(:sender_name){ should == "server4" }
+        its(:properties){ should == {'bar' => "DEF", 'baz' => 777}}
+      end
+    end
+
+    it "raise ArgumentError for invalid attribute name" do
+      expect{
+        Tengine::Event.parse({'name' => :foo}.to_json)
+      }.to raise_error(NoMethodError)
+    end
+
+  end
+
+  describe "#transmitted?" do
+
+    subject { Tengine::Event.new }
+
+    it "returns false while not transmitted" do
+      Tengine::Mq::Suite.stub(:pending?).with(subject).and_return(true)
+      subject.transmitted?.should be_false
+    end
+
+    it "returns true once transmitted" do
+      Tengine::Mq::Suite.stub(:pending?).with(subject).and_return(false)
+      subject.transmitted?.should be_true
+    end
+  end
+
+end