tengine_core 0.5.28

data/spec/tengine/core/mutex_spec.rb

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'tengine/core'
+
+describe Tengine::Core::Mutex do
+  before do
+    Tengine::Core::Mutex::Mutex.delete_all
+  end
+
+  context "#new" do
+    subject { Tengine::Core::Mutex.new "test mutex 01" }
+
+    it { should be_kind_of(Tengine::Core::Mutex) }
+    its(:mutex) { should be_kind_of(Tengine::Core::Mutex::Mutex) }
+    its(:recursive) { should be_zero }
+
+    context "negative ttl" do
+      it { expect { Tengine::Core::Mutex.new "test negative ttl", -1 }.to raise_exception(ArgumentError) }
+    end
+
+    context "infinite ttl" do
+      it { expect { Tengine::Core::Mutex.new "test negative ttl", (1.0 / 0.0) }.to raise_exception(TypeError) }
+    end
+  end
+
+  context "#synchronize" do
+    subject { Tengine::Core::Mutex.new "test mutex 01", Math::PI / 10 }
+
+    it "requires block" do
+      expect {
+        subject.synchronize
+      }.to raise_exception(ArgumentError)
+    end
+
+    it "synchronizes #0: no other lockers" do
+      block_called = false
+      EM.run_block do
+        subject.synchronize do
+          block_called = true
+        end
+      end
+      block_called.should be_true
+    end
+
+    it "synchronizes #1: with another locker, which is expired" do
+      # "stub" waiters
+      m = subject.mutex
+      m.waiters ||= []
+      m.waiters << { :_id => 1, :timeout => Time.at(0) }
+      m.save
+
+      block_called = false
+      t0 = Time.now
+      EM.run_block do
+        subject.synchronize do
+          block_called = true
+        end
+      end
+      t1 = Time.now
+      block_called.should be_true
+      m.reload.waiters.should be_empty
+      (t1 - t0).should be_within(0.5).of(0) #immediate
+    end
+
+    it "synchronizes #2: with another locker, which is expiring" do
+      # "stub" waiters
+      m = subject.mutex
+      m.waiters ||= []
+      m.waiters << { :_id => 1, :timeout => Time.now + m.ttl / 2 }
+      m.save
+
+      block_called = false
+      t0 = Time.now
+      EM.run do
+        subject.synchronize do
+          block_called = true
+          EM.stop
+        end
+      end
+      t1 = Time.now
+      block_called.should be_true
+      m.reload.waiters.should be_empty
+      (t1 - t0).should be_within(0.5).of(0.3 + m.ttl)
+    end
+
+    it "synchronizes #3: with another locker, which is not expiring" do
+      # "stub" waiters
+      m = subject.mutex
+      s = mock("mutex")
+      s.stub("_id").and_return(1)
+      m.waiters ||= []
+      m.waiters << { :_id => s._id, :timeout => Time.now + 10 }
+      m.save
+
+      block_called = false
+      t0 = Time.now
+      EM.run do
+        EM.add_timer 5 do
+          m.unlock s
+        end
+        subject.synchronize do
+          block_called = true
+          EM.stop
+        end
+      end
+      t1 = Time.now
+      block_called.should be_true
+      m.reload.waiters.should be_empty
+      (t1 - t0).should be_within(0.5).of(5 + m.ttl)
+    end
+
+    it "synchronizes #4: multi-threaded situation" do
+      x = y = z = nil
+
+      EM.run do
+        EM.defer do
+          m = Tengine::Core::Mutex.new "test mutex 02"
+          m.synchronize do
+            x = Time.now.to_f
+          end
+          y = Time.now.to_f
+        end
+
+        EM.defer do
+          sleep 0.5
+          m = Tengine::Core::Mutex.new "test mutex 02"
+          m.synchronize do
+            z = Time.now.to_f
+          end
+        end
+
+        EM.add_timer(2.5) do
+          EM.stop
+        end
+      end
+
+      x.should_not be_nil
+      y.should_not be_nil
+      z.should_not be_nil
+      x.should < z
+      y.should <= z
+    end
+  end
+
+  context "#heartbeat" do
+    subject { Tengine::Core::Mutex.new "test mutex 01", Math::PI / 10 }
+
+    it "prevents automatic unlocking" do
+      m = subject.mutex
+      t1 = nil
+      t0 = Time.now.to_f
+      EM.run do
+        EM.defer do
+          subject.synchronize do
+            20.times do
+              subject.heartbeat
+              sleep(m.ttl / 2)
+            end
+          end
+        end
+        EM.defer do
+          sleep m.ttl
+          loop do
+            # hacky...
+            if h = m.reload.waiters.first
+              if h["timeout"] < Time.now
+                t1 = Time.now.to_f
+                EM.stop
+                break
+              end
+            else
+              t1 = Time.now.to_f
+              EM.stop
+              break
+            end
+          end
+        end
+      end
+
+      t1.should_not be_nil
+      (t1 - t0).should be_within(0.5).of(10 * subject.mutex.ttl)
+    end
+  end
+end

data/spec/tengine/core/optimistic_lock_spec.rb

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Tengine::Core::OptimisticLock do
+
+  class Tengine::Core::OptimisticLockTestBox1
+    include Mongoid::Document
+    include Tengine::Core::OptimisticLock
+
+    set_locking_field :version
+
+    field :version, :type => Integer
+    field :value, :type => String
+  end
+
+  context "update_with_lock" do
+    before do
+      @test_box1 = Tengine::Core::OptimisticLockTestBox1.create!(:version => 2, :value => "foo")
+    end
+
+    it "競合がなければ素直に更新する" do
+      test_box = Tengine::Core::OptimisticLockTestBox1.find(@test_box1.id)
+      test_box.update_with_lock do
+        test_box.value += "o"
+      end
+      test_box.reload
+      test_box.value.should == "fooo"
+      test_box.version.should == 3
+    end
+
+    it "競合しても単純に上書きしたりせず、最新を取得し直して更新する" do
+      test_box1 = Tengine::Core::OptimisticLockTestBox1.find(@test_box1.id)
+      test_box2 = Tengine::Core::OptimisticLockTestBox1.find(@test_box1.id)
+      # test_box1を更新
+      test_box1_count = 0
+      test_box1.update_with_lock do
+        test_box1_count += 1
+        test_box1.value += "o"
+      end
+      test_box1_count.should == 1
+      test_box1.value.should == "fooo"
+      test_box1.version.should == 3
+      # test_box2を更新
+      test_box2_count = 0
+      test_box2.update_with_lock do
+        test_box2_count += 1
+        test_box2.value += "w"
+      end
+      test_box2_count.should == 2
+      test_box2.value.should == "fooow"
+      test_box2.version.should == 4
+    end
+  end
+
+end

data/spec/tengine/core/scheculer_spec.rb

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'amqp'
+
+require_relative '../../../lib/tengine/core/scheduler'
+require 'tengine/mq/suite'
+
+describe Tengine::Core::Scheduler do
+  before do
+    Tengine::Core::Schedule.delete_all
+    @uuid = UUID.new
+  end
+
+  subject do
+    Tengine::Core::Scheduler.new(%w[--heartbeat-atd-interval=30])
+  end
+
+  describe "#search_for_schedule" do
+
+    before do
+      @fixtures = Array.new
+      @fixtures << Tengine::Core::Schedule.new(event_type_name: "stop.execution.job.tengine", scheduled_at: 1.day.ago)
+      @fixtures << Tengine::Core::Schedule.new(event_type_name: "stop.execution.job.tengine", scheduled_at: Time.now + 10)
+      @fixtures << Tengine::Core::Schedule.new(event_type_name: "stop.execution.job.tengine", scheduled_at: 1.day.ago, status: Tengine::Core::Schedule::FIRED)
+      @fixtures.each {|i| i.save! }
+    end
+
+    it "古いものを検索してくる" do
+      EM.stub(:next_tick).and_yield
+      set = []
+      subject.search_for_schedule do |i|
+        set << i
+      end
+
+      set.should include(@fixtures[0])
+      set.should_not include(@fixtures[1])
+      set.should_not include(@fixtures[2])
+    end
+  end
+
+  describe "#send_last_event" do
+    it "finished.process.atd.tengineの発火" do
+      sender = mock(:sender)
+      subject.stub(:sender).and_return(sender)
+      sender.should_receive(:fire).with("finished.process.atd.tengine", an_instance_of(Hash))
+      sender.should_receive(:stop)
+      subject.send_last_event
+    end
+  end
+
+  describe "#send_periodic_event" do
+    it "atd.heartbeat.tengineの発火" do
+      sender = mock(:sender)
+      subject.stub(:sender).and_return(sender)
+      sender.should_receive(:fire).with("atd.heartbeat.tengine", an_instance_of(Hash))
+      sender.stub(:fire).with("finished.process.atd.tengine", an_instance_of(Hash)) # 来るかも
+      subject.send_periodic_event
+    end
+  end
+
+  describe "#send_scheduled_event" do
+    it "スケジュールされたイベントの発火" do
+      s0 = Tengine::Core::Schedule.new(event_type_name: "test.event.not.tengine", source_name: "test://localhost/dev/null", properties: {foo: 'bar'})
+      sender = mock(:sender)
+      subject.stub(:sender).and_return(sender)
+      sender.should_receive(:fire).with(s0.event_type_name, an_instance_of(Hash)) do |e1, h|
+        h[:source_name].should == s0.source_name
+        h[:properties].should == {:foo => 'bar'}
+        h[:key].should == s0._id
+      end
+
+      subject.send_scheduled_event s0
+    end
+  end
+
+  describe "#mark_schedule_done" do
+    it "実行したスケジュールは終了とする" do
+      s0 = Tengine::Core::Schedule.new(event_type_name: "test.event.not.tengine", source_name: "test://localhost/dev/null")
+      s0.save
+      subject.mark_schedule_done s0
+      s0.reload
+      s0.status.should == Tengine::Core::Schedule::FIRED
+    end
+
+    it "すでに終了していたら何もしない" do
+      s0 = Tengine::Core::Schedule.new(event_type_name: "test.event.not.tengine", source_name: "test://localhost/dev/null", status: Tengine::Core::Schedule::FIRED)
+      s0.save
+      s0.reload
+      t = s0.updated_at
+      subject.mark_schedule_done s0
+      s0.reload
+      s0.updated_at.should == t
+    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::Scheduler.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/selectable_attr_spec.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+require 'stringio'
+
+describe Tengine::Core::SelectableAttr do
+
+  module TestModule1
+    class TestClass1
+      include Tengine::Core::SelectableAttr
+      selectable_attr :foo do
+        entry 1, :a, "do"
+        entry 2, :b, "re"
+        entry 3, :c, "mi"
+      end
+      multi_selectable_attr :bar do
+        entry 1, :x, "red"
+        entry 2, :y, "green"
+        entry 3, :z, "blue"
+      end
+    end
+  end
+
+  it "i18n_scopeが設定されている" do
+    TestModule1::TestClass1.foo_enum.i18n_scope.should == ['selectable_attrs', 'test_module1/test_class1', 'foo']
+    TestModule1::TestClass1.bar_enum.i18n_scope.should == ['selectable_attrs', 'test_module1/test_class1', 'bar']
+  end
+
+
+end

data/spec/tengine/core/session_spec.rb

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Tengine::Core::Session do
+  context "should save Hash as properties" do
+    subject do
+      Tengine::Core::Session.create!(:properties => {
+          "key1" => 100,
+          "key2" => "string value",
+          "key3" => Time.utc(2011,9,4,20,58),
+          :key4 => [:array, "of", "variables", true, false, nil, 99.9999],
+          :key5 => {:nested => "hash"},
+          :key6 => :symbol_value,
+        })
+    end
+    it do
+      subject.properties["key1"].should == 100
+      subject.properties["key2"].should == "string value"
+      subject.properties["key3"].should == Time.utc(2011,9,4,20,58)
+      subject.properties[:key4].should == [:array, "of", "variables", true, false, nil, 99.9999]
+      subject.properties[:key5].should == {:nested => "hash"}
+      subject.properties[:key6].should == :symbol_value
+    end
+    it "should allow to read properties by using []" do
+      subject["key1"].should == 100
+      subject["key2"].should == "string value"
+      subject["key3"].should == Time.utc(2011,9,4,20,58)
+      subject[:key4].should == [:array, "of", "variables", true, false, nil, 99.9999]
+      subject[:key5].should == {:nested => "hash"}
+      subject[:key6].should == :symbol_value
+    end
+    it "should allow to write properties by using []=" do
+      subject["key1"] = 99
+      subject["key1"].should == 99
+    end
+  end
+
+  describe :update_with_lock do
+    before do
+      @session1 = Tengine::Core::Session.create!(
+        :lock_version => 2,
+        :properties => {
+          "key1" => 100,
+          "key2" => "string value",
+          "key3" => Time.utc(2011,9,4,20,58),
+          :key4 => [:array, "of", "variables", true, false, nil, 99.9999],
+          :key5 => {:nested => "hash"},
+          :key6 => :symbol_value,
+        })
+    end
+
+    it "競合がなければ素直に更新する" do
+      session = Tengine::Core::Session.find(@session1.id)
+      session.update_with_lock do
+        session.properties['key1'] += 1
+      end
+      session.reload
+      session.properties['key1'].should == 101
+    end
+
+    it "競合しても単純に上書きしたりせず、最新を取得し直して更新する" do
+      session1 = Tengine::Core::Session.find(@session1.id)
+      session2 = Tengine::Core::Session.find(@session1.id)
+      # session1を更新
+      session1.update_with_lock do
+        session1.properties['key1'] += 1
+      end
+      session1.properties['key1'].should == 101
+      # session2を更新
+      session1.update_with_lock do
+        session1.properties['key1'] += 1
+      end
+      session1.properties['key1'].should == 102
+    end
+
+    it "リトライ回数をオーバーすると例外が発生する" do
+      session1 = Tengine::Core::Session.find(@session1.id)
+      session2 = Tengine::Core::Session.find(@session1.id)
+
+      session1.update_with_lock{ session1.properties['key1'] += 1 } # [2] 100 -> [3] 101
+
+      f = Fiber.new do
+        session2.update_with_lock(:retry => 3) do
+          Fiber.yield
+          session1.properties['key1'] += 1
+        end
+      end
+      f.resume # [2] 100 -> [3] 101 を試みて失敗
+
+      session1.reload; session1.update_with_lock{ session1.properties['key1'] += 1 } # [3] 101 -> [4] 102
+      f.resume # [3] 101 -> [4] 102 を試みて失敗。リトライ1回
+
+      session1.reload; session1.update_with_lock{ session1.properties['key1'] += 1 } # [4] 102 -> [5] 103
+      f.resume # [4] 102 -> [5] 103 を試みて失敗。リトライ2回
+
+      session1.reload; session1.update_with_lock{ session1.properties['key1'] += 1 } # [5] 103 -> [6] 104
+      expect{
+        f.resume # [5] 103 -> [6] 104 を試みて失敗。リトライ3回失敗したので、例外がraiseされる
+      }.to raise_error(Tengine::Core::OptimisticLock::RetryOverError)
+    end
+
+  end
+
+end