rx 0.0.2

data/test/rx_ruby/concurrency/test_current_thread_scheduler.rb

@@ -0,0 +1,44 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'test_helper'
+require 'rx_ruby/concurrency/helpers/immediate_local_scheduler_helper'
+
+
+class TestCurrentThreadScheduler < Minitest::Test
+  include ImmediateLocalSchedulerTestHelper
+
+  def setup
+    @scheduler = RxRuby::CurrentThreadScheduler.instance
+  end
+
+  def test_schedule_required
+    assert_equal(true, RxRuby::CurrentThreadScheduler.schedule_required?)
+  end
+
+  def test_schedule
+    ran = false
+    @scheduler.schedule -> { ran = true }
+
+    assert_equal(true, ran)
+  end
+
+  def test_schedule_runs_in_current_thead
+    id = Thread.current.object_id
+    @scheduler.schedule -> { assert_equal(id, Thread.current.object_id) }
+  end
+
+  def test_schedule_error_raises
+    assert_raises(StandardError) do
+      @scheduler.schedule -> { raise StandardError }
+    end
+  end
+
+  def test_schedule_nested
+    ran = false
+    @scheduler.schedule -> do
+      @scheduler.schedule -> { ran = true }
+    end
+
+    assert_equal(true, ran)
+  end
+end

data/test/rx_ruby/concurrency/test_default_scheduler.rb

@@ -0,0 +1,44 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'test_helper'
+
+# DefaultScheduler creates new threads in which to run scheduled tasks; a short
+# sleep is necessary to allow the thread scheduler to yield to the other
+# threads.
+class TestDefaultScheduler < Minitest::Test
+
+  def setup
+    @scheduler = RxRuby::DefaultScheduler.instance
+  end
+
+  def test_schedule_with_state
+    state = []
+    task  = ->(_, s) { s << 1 }
+    d = @scheduler.schedule_with_state(state, task)
+    sleep 0.001
+
+    assert_equal([1], state)
+  end
+
+  def test_schedule_relative_with_state
+    state = []
+    task  = ->(_, s) { s << 1 }
+    d = @scheduler.schedule_relative_with_state(state, 0.05, task)
+    sleep 0.1
+
+    assert_equal([1], state)
+  end
+
+  def test_default_schedule_runs_in_its_own_thread
+    id = Thread.current.object_id
+    @scheduler.schedule -> { refute_equal(id, Thread.current.object_id) }
+    sleep 0.001
+  end
+
+  def test_schedule_action_cancel
+    task = -> { flunk "This should not run." }
+    subscription = @scheduler.schedule_relative(0.05, task)
+    subscription.unsubscribe
+    sleep 0.1
+  end
+end

data/test/rx_ruby/concurrency/test_historical_scheduler.rb

@@ -0,0 +1,18 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'test_helper'
+require 'rx_ruby/concurrency/helpers/historical_virtual_scheduler_helper'
+
+class TestHistoricalScheduler < Minitest::Test
+  include HistoricalVirtualSchedulerTestHelper
+
+  def setup
+    @start     = Time.at(1000)
+    @scheduler = RxRuby::HistoricalScheduler.new(@start)
+  end
+
+  def test_initialization
+    assert_equal(Time.at(1000), @scheduler.now)
+    assert_equal(Time.at(0), RxRuby::HistoricalScheduler.new.now)
+  end
+end

data/test/rx_ruby/concurrency/test_immediate_scheduler.rb

@@ -0,0 +1,53 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'test_helper'
+require 'rx_ruby/concurrency/helpers/immediate_local_scheduler_helper'
+
+class TestImmediateScheduler < Minitest::Test
+  include ImmediateLocalSchedulerTestHelper
+
+  def setup
+    @scheduler = RxRuby::ImmediateScheduler.instance
+  end
+
+  def test_now
+    assert_equal(Time.now.to_i, @scheduler.now.to_i)
+  end
+
+  def test_immediate_schedule
+    ran = false
+    @scheduler.schedule -> { ran = true }
+    assert_equal(true, ran)
+  end
+
+  def test_immediate_schedule_runs_in_current_thread
+    id = Thread.current.object_id
+    @scheduler.schedule -> { assert_equal(id, Thread.current.object_id) }
+  end
+
+  def test_schedule_error_raises
+    task = -> do
+      raise(StandardError)
+      flunk "Should not be reached."
+    end
+
+    assert_raises(StandardError) { @scheduler.schedule(task) }
+  end
+
+  def test_schedule_with_state_simple
+    state = []
+    task = ->(_, s) { s << 1 }
+    @scheduler.schedule_with_state(state, task)
+
+    assert_equal([1], state)
+  end
+
+  def test_schedule_recursive_with_state_simple
+    state = []
+    inner = ->(_, s) { s << 1 }
+    outer = ->(sched, s) { sched.schedule_with_state(s, inner) }
+    @scheduler.schedule_with_state(state, outer)
+
+    assert_equal([1], state)
+  end
+end

data/test/rx_ruby/concurrency/test_local_scheduler.rb

@@ -0,0 +1,12 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'test_helper'
+require 'rx_ruby/concurrency/helpers/immediate_local_scheduler_helper'
+
+class TestLocalcheduler < Minitest::Test
+  include ImmediateLocalSchedulerTestHelper
+
+  def setup
+    @scheduler = RxRuby::LocalScheduler.new
+  end
+end

data/test/rx_ruby/concurrency/test_periodic_scheduler.rb

@@ -0,0 +1,53 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'test_helper'
+
+class PeriodicTestClass
+  include RxRuby::PeriodicScheduler
+end
+
+class TestPeriodicScheduler < Minitest::Test
+  def setup
+    @scheduler = PeriodicTestClass.new
+  end
+
+  def test_periodic_with_state
+    state = []
+    task  = ->(x) { x << 1 }
+
+    subscription = @scheduler.schedule_periodic_with_state(state, 0.01, task)
+    sleep 0.025
+    subscription.unsubscribe
+    assert_equal(state.length, 2)
+  end
+
+  def test_periodic_with_state_exceptions
+    assert_raises(RuntimeError) do
+      @scheduler.schedule_periodic_with_state([], 0.01, nil)
+    end
+
+    assert_raises(RuntimeError) do
+      @scheduler.schedule_periodic_with_state([], -1, ->{})
+    end
+  end
+
+  def test_periodic
+    state = []
+    task  = ->() { state << 1 }
+
+    subscription = @scheduler.schedule_periodic(0.01, task)
+    sleep 0.025
+    subscription.unsubscribe
+    assert_equal(state.length, 2)
+  end
+
+  def test_periodic_exceptions
+    assert_raises(RuntimeError) do
+      @scheduler.schedule_periodic(0.01, nil)
+    end
+
+    assert_raises(RuntimeError) do
+      @scheduler.schedule_periodic(-1, ->{})
+    end
+  end
+end

data/test/rx_ruby/concurrency/test_scheduled_item.rb

@@ -0,0 +1,50 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'test_helper'
+
+class DummyScheduler
+end
+
+class TestScheduledItem < Minitest::Test
+
+  def setup
+    @state = []
+    @item  = RxRuby::ScheduledItem.new(DummyScheduler.new, @state, 5) do |_, state|
+      state << 1
+    end
+  end
+
+  def test_cancel
+    assert_equal(false, @item.cancelled?)
+    @item.cancel
+    assert_equal(true, @item.cancelled?)
+  end
+
+  def test_invocation
+    less = RxRuby::ScheduledItem.new(DummyScheduler.new, @state, 0)
+    more = RxRuby::ScheduledItem.new(DummyScheduler.new, @state, 10)
+    same = RxRuby::ScheduledItem.new(DummyScheduler.new, @state, 5)
+
+    assert(less < @item)
+    assert(more > @item)
+    assert_equal(same, @item)
+  end
+
+  def test_invoke
+    @item.invoke
+    assert_equal([1], @state)
+  end
+
+  def test_invoke_raises_on_subsequent_calls
+    @item.invoke
+    assert_raises(RuntimeError) { @item.invoke }
+  end
+
+  def test_cancel
+    assert_equal(false, @item.cancelled?)
+    @item.cancel
+    assert_equal(true, @item.cancelled?)
+    @item.invoke
+    assert_equal([], @state)
+  end
+end

data/test/rx_ruby/concurrency/test_scheduler.rb

@@ -0,0 +1,128 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'thread'
+require 'test_helper'
+
+class MyScheduler
+  include RxRuby::Scheduler
+
+  attr_reader :now
+  attr_accessor :wait_cycles
+
+  def initialize(now = Time.now)
+    @now = now
+    @wait_cycles = 0
+    @check = nil
+  end
+
+  def check(&action)
+    @check = action
+  end
+
+  def schedule_with_state(state, action)
+    action.call self, state
+  end
+
+  def schedule_relative_with_state(state, due_time, action)
+    @check.call(lambda {|o| action.call(self, o)}, state, due_time)
+    @wait_cycles += due_time
+    action.call(self, state)
+  end
+
+  def schedule_absolute_with_state(state, due_time, action)
+    self.schedule_relative_with_state(state, due_time - now, action)
+  end
+end
+
+class TestBaseScheduler < Minitest::Test
+
+  def setup
+    @scheduler = MyScheduler.new
+  end
+
+  def test_now
+    assert_equal(Time.now.to_i, RxRuby::Scheduler.now.to_i)
+  end
+
+  def test_schedule_absolute
+    due  = Time.now + 1
+    ran  = false
+    task = ->() { ran = true }
+
+    @scheduler.check { |a, s, t| assert_equal(1, t.to_i) }
+    @scheduler.schedule_absolute(due, task)
+
+    assert_equal(true, ran)
+    assert_equal(1, @scheduler.wait_cycles.to_i)
+  end
+
+  def test_schedule_non_recursive
+    ran = false
+    @scheduler.schedule_recursive(->(a) { ran = true })
+    assert_equal(true, ran)
+  end
+
+  def test_schedule_recursive
+    calls = 0
+    task = ->(a) do
+      calls += 1
+      a.call if calls < 10
+    end
+    @scheduler.schedule_recursive(task)
+
+    assert_equal(10, calls)
+  end
+
+  def test_schedule_recursive_absolute_non_recursive
+    now = Time.now
+    ran = false
+
+    @scheduler.check { |a, s, t| assert_equal(0, t.to_i) }
+    @scheduler.schedule_recursive_absolute(now, ->(a) { ran = true })
+    assert_equal(true, ran)
+    assert_equal(0, @scheduler.wait_cycles.to_i)
+  end
+
+  def test_schedule_recursive_absolute_recursive
+    now   = Time.now
+    calls = 0
+    task  = ->(a) do
+      calls += 1
+      a.call(now) if calls < 10
+    end
+
+    @scheduler.check { |a, s, t| assert_equal(0, t.to_i) }
+    @scheduler.schedule_recursive_absolute(now, task)
+
+    assert_equal(0, @scheduler.wait_cycles.to_i)
+    assert_equal(10, calls)
+  end
+
+  def test_schedule_recursive_relative_non_recursive
+    now  = Time.now
+    ran  = false
+    task = ->(a) { ran = true }
+
+    @scheduler.check { |a, s, t| assert_equal(0, t.to_i) }
+    @scheduler.schedule_recursive_relative(0, task)
+
+    assert_equal(true, ran)
+    assert_equal(0, @scheduler.wait_cycles)
+  end
+
+  def test_schedule_recursive_relative_recursive
+    now   = Time.now
+    calls = 0
+    task  = ->(a) do
+      calls += 1
+      a.call(calls) if calls < 10
+    end
+
+    @scheduler.check { |a, s, t| assert_operator(t, :<, 10) }
+
+    @scheduler.schedule_recursive_relative(0, task)
+    assert_equal(45, @scheduler.wait_cycles)
+    assert_equal(10, calls)
+  end
+
+end

data/test/rx_ruby/concurrency/test_virtual_time_scheduler.rb

@@ -0,0 +1,14 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'test_helper'
+require 'rx_ruby/concurrency/helpers/historical_virtual_scheduler_helper'
+
+class TestVirtualTimeScheduler < Minitest::Test
+
+  include HistoricalVirtualSchedulerTestHelper
+
+  def setup
+    @start     = Time.now.to_i
+    @scheduler = RxRuby::VirtualTimeScheduler.new(@start)
+  end
+end

data/test/rx_ruby/core/test_notification.rb

@@ -0,0 +1,129 @@
+# Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+require 'test_helper'
+
+class TestNotification < Minitest::Test
+  include RxRuby::ReactiveTest
+
+  def test_to_observable_empty
+    scheduler = RxRuby::TestScheduler.new
+
+    res = scheduler.configure do 
+      RxRuby::Notification.create_on_completed.to_observable(scheduler)
+    end
+
+    assert_messages [on_completed(201)], res.messages
+  end
+
+  def test_to_observable_just
+    scheduler = RxRuby::TestScheduler.new
+
+    res = scheduler.configure do 
+      RxRuby::Notification.create_on_next(42).to_observable(scheduler)
+    end
+
+    assert_messages [on_next(201, 42), on_completed(201)], res.messages
+  end
+
+  def test_to_observable_raise
+    err = RuntimeError.new
+    scheduler = RxRuby::TestScheduler.new
+
+    res = scheduler.configure do 
+      RxRuby::Notification.create_on_error(err).to_observable(scheduler)
+    end
+
+    assert_messages [on_error(201, err)], res.messages
+  end
+
+  def test_notification_equality
+    n = RxRuby::Notification.create_on_next(42)
+    e = RxRuby::Notification.create_on_error(RuntimeError.new)
+    c = RxRuby::Notification.create_on_completed
+
+    n1 = n
+    n2 = n
+    e1 = e
+    e2 = e
+    c1 = c
+    c2 = c
+
+    assert(n1 == n2)
+    assert(e1 == e2)
+    assert(c1 == c2) 
+
+    assert(n1.eql? n2)
+    assert(e1.eql? e2)
+    assert(c1.eql? c2)       
+  end
+
+  def test_on_next_initialize
+    n = RxRuby::Notification.create_on_next(42)
+
+    assert n.on_next?
+    assert n.has_value?
+    assert_equal 42, n.value
+  end
+
+  def test_on_next_equality
+    n1 = RxRuby::Notification.create_on_next(42)
+    n2 = RxRuby::Notification.create_on_next(42)
+    n3 = RxRuby::Notification.create_on_next(24)
+    n4 = RxRuby::Notification.create_on_completed
+
+    assert(n1.eql? n1)
+    assert(n1.eql? n2)
+    refute(n1.eql? n3)
+    refute(n3.eql? n1)
+    refute(n1.eql? n4)
+    refute(n4.eql? n1)
+  end
+
+  def test_on_next_to_s
+    n = RxRuby::Notification.create_on_next(42)
+    s = n.to_s
+
+    assert (s.include? '42')
+    assert (s.include? 'on_next')
+  end
+
+  class AcceptObserver
+    include RxRuby::Observer
+
+    def initialize
+      @config = RxRuby::ObserverConfiguration.new
+      yield @config
+    end
+
+    def on_next(value)
+      @config.on_next_action.call value
+    end
+
+    def on_error(error)
+      @config.on_error_action.call error
+    end
+
+    def on_completed
+      @config.on_completed_action.call
+    end
+  end
+
+  class CheckOnNextObserver
+    attr_reader :value
+
+    include RxRuby::Observer
+
+    def on_next(value)
+      @value = value
+    end
+  end
+
+  def test_on_next_accept
+    con = CheckOnNextObserver.new
+    n1 = RxRuby::Notification.create_on_next(42)
+    n1.accept(con)
+
+    assert_equal 42, con.value
+  end
+
+end