tengine_core 0.5.39 → 1.1.0

data/spec/tengine/core/mongodb_spec.rb

@@ -1,12 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'spec_helper'
-
-describe "MongoDB" do
-
-  context "server version must be >= 2.0.x" do
-    subject{ Mongoid.database.connection.server_version }
-    it{ should be_a(Mongo::ServerVersion)}
-    its(:to_s){ should =~ /^2\.\d+\./ }
-  end
-
-end

data/spec/tengine/core/mongoid_fix_spec.rb

@@ -1,52 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'spec_helper'
-require 'tengine/core/mongoid_fix'
-
-describe Mongoid::Cursor do
-
-  class TestDocument
-    include Mongoid::Document
-  end
-
-  [
-   Mongo::ConnectionFailure,
-   Mongo::OperationTimeout,
-   Mongo::OperationFailure
-  ].each do |e|
-
-    context e do
-
-      subject { TestDocument.all }
-
-      before(:all) { TestDocument.new.save }
-
-      before do
-        ex = e.new "not master"
-        @m = Mongoid.max_retries_on_connection_failure
-        Mongoid.max_retries_on_connection_failure = 32
-        n = 0
-        Mongo::Cursor.any_instance.stub(:next) do
-          n += 1
-          raise ex while n < 1
-          nil
-        end
-      end
-
-      after do
-        Mongoid.max_retries_on_connection_failure = @m
-#        Mongo::Cursor.any_instance.unstub(:next)
-        TestDocument.delete_all
-      end
-
-      it do
-        begin
-          subject.to_a
-        rescue Exception
-          puts $!.backtrace
-        end
-      end
-      # its(:to_a) { should be_empty }
-    end
-  end
-
-end

data/spec/tengine/core/mutex_spec.rb

@@ -1,201 +0,0 @@
-# -*- 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(1.0).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(1.0).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
-
-    it "synchronizes #5: no stack overflow" do
-      STDERR.puts "This test takes two minutes to run.  Relax and take a cup of coffee."
-      m = Tengine::Core::Mutex.new "test mutex 03", 0.00000000001
-      n = m.mutex
-      n.waiters ||= []
-      n.waiters << { :_id => 1, :timeout => Time.now + 120 }
-      n.save
-
-      expect do
-        EM.run do
-          m.synchronize do
-            EM.stop
-          end
-        end
-      end.to_not raise_error(SystemStackError)
-    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(1.0).of(10 * subject.mutex.ttl)
-    end
-  end
-end

data/spec/tengine/core/optimistic_lock_spec.rb

@@ -1,55 +0,0 @@
-# -*- 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

@@ -1,121 +0,0 @@
-# -*- 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

@@ -1,30 +0,0 @@
-# -*- 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