a-ruby-promise 0.0.1

data/spec/promises_aplus/2_2_2_spec.rb

@@ -0,0 +1,156 @@
+# encoding: UTF-8
+require_relative "../spec_helper"
+require_relative "../promises_aplus"
+
+dummy = { dummy: "dummy" } #  we fulfill or reject with this when we don't intend to test against it
+sentinel = { sentinel: "sentinel" } # a sentinel fulfillment value to test for with strict equality
+
+describe "2.2.2: If `onFulfilled` is a function," do
+  include PromisesAplus
+
+  describe "2.2.2.1: it must be called after `promise` is fulfilled, with `promise`’s fulfillment value as its first argument." do
+    PromisesAplus.test_fulfilled(self, sentinel) do |promise, done|
+      promise.then ->(value) {
+        value.must_equal sentinel
+        done.call
+      }
+    end
+  end
+
+  describe "2.2.2.2: it must not be called before `promise` is fulfilled" do
+
+    it "fulfilled after a delay" do
+      d = deferred
+      is_fulfilled = false
+      d.promise.then ->(v) {
+        assert_equal true, is_fulfilled
+        done!
+      }
+
+      Thread.new do
+        short_sleep
+        # Notice: flipped statements since we don't have delayed execution
+        is_fulfilled = true
+        d.resolve(dummy)
+      end
+    end
+
+    it "never fulfilled" do
+      d = deferred
+      on_fulfilled_called = false
+
+      d.promise.then ->(v) {
+        on_fulfilled_called = true
+        done!
+      }
+
+      done = method(:done!)
+      Thread.new do
+        3.times { short_sleep }
+        assert_equal false, on_fulfilled_called
+        done.call
+      end
+    end
+  end
+
+  describe "2.2.2.3: it must not be called more than once." do
+    it "already-fulfilled" do
+      times_called = 0
+
+      resolved(dummy).then(->(v) {
+        (times_called += 1).must_equal 1
+        done!
+      })
+    end
+
+    it "trying to fulfill a pending promise more than once, immediately" do
+      d = deferred
+      times_called = 0
+
+      d.promise.then(->(v) {
+        (times_called += 1).must_equal 1
+        done!
+      })
+
+      d.resolve(dummy)
+      d.resolve(dummy)
+    end
+
+    it "trying to fulfill a pending promise more than once, delayed" do
+      d = deferred
+      times_called = 0
+
+      d.promise.then(->(v) {
+        assert_equal 1, (times_called += 1)
+        done!
+      })
+
+      Thread.new do
+        short_sleep
+        d.resolve(dummy)
+        d.resolve(dummy)
+      end
+    end
+
+    it "trying to fulfill a pending promise more than once, immediately then delayed" do
+      d = deferred
+      times_called = 0
+
+      d.promise.then(->(v) {
+        (times_called += 1).must_equal 1
+        done!
+      })
+
+      d.resolve(dummy)
+      Thread.new do
+        short_sleep
+        d.resolve(dummy)
+      end
+    end
+
+    it "when multiple `then` calls are made, spaced apart in time" do
+      d = deferred
+      times_called = [0, 0, 0]
+
+      d.promise.then(->(v) {
+        assert_equal 1, (times_called[0] += 1)
+      })
+
+      Thread.new do
+        short_sleep
+        d.promise.then(->(v) {
+          assert_equal 1, (times_called[1] += 1)
+        })
+      end
+
+      Thread.new do
+        2.times { short_sleep }
+        d.promise.then(->(v) {
+          assert_equal 1, (times_called[2] += 1)
+          done!
+        })
+      end
+
+      Thread.new do
+        3.times { short_sleep }
+        d.resolve(dummy)
+      end
+    end
+
+    it "when `then` is interleaved with fulfillment" do
+      d = deferred
+      times_called = [0, 0]
+
+      d.promise.then(->(v) {
+        (times_called[0] += 1).must_equal 1
+      })
+
+      d.resolve(dummy)
+
+      d.promise.then(->(v) {
+        (times_called[1] += 1).must_equal 1
+        done!
+      })
+    end
+  end
+end

data/spec/promises_aplus/2_2_3_spec.rb

@@ -0,0 +1,142 @@
+# encoding: UTF-8
+require_relative "../spec_helper"
+require_relative "../promises_aplus"
+
+dummy = { dummy: "dummy" }
+sentinel = { sentinel: "sentinel" }
+
+describe "2.2.3: If `onRejected` is a function," do
+  include PromisesAplus
+
+  describe "2.2.3.1: it must be called after `promise` is rejected, with `promise`’s rejection reason as its first argument." do
+    PromisesAplus.test_rejected(self, sentinel) do |promise, done|
+      promise.then nil, ->(reason) {
+        reason.must_equal sentinel
+        done.call
+      }
+    end
+  end
+
+  describe "2.2.3.2: it must not be called before `promise` is rejected" do
+
+    it "rejected after a delay" do
+      d = deferred
+      is_rejected = false
+      d.promise.then(nil, ->(r) {
+        is_rejected.must_equal true
+        done!
+      })
+
+      sleep 0.050
+      is_rejected = true
+      d.reject(dummy)
+    end
+
+    it "never rejected" do
+      d = deferred
+      on_rejected_called = false
+
+      d.promise.then(nil, ->(r) {
+        on_rejected_called = true
+        done!
+      })
+
+      sleep 0.150
+      on_rejected_called.must_equal false
+      done!
+    end
+  end
+
+  describe "2.2.3.3: it must not be called more than once." do
+    it "already-rejected" do
+      times_called = 0
+
+      rejected(dummy).then(nil, ->(r) {
+        (times_called += 1).must_equal 1
+        done!
+      })
+    end
+
+    it "trying to reject a pending promise more than once, immediately" do
+      d = deferred
+      times_called = 0
+
+      d.promise.then(nil, ->(r) {
+        (times_called += 1).must_equal 1
+        done!
+      })
+
+      d.reject(dummy)
+      d.reject(dummy)
+    end
+
+    it "trying to reject a pending promise more than once, delayed" do
+      d = deferred
+      times_called = 0
+
+      d.promise.then(nil, ->(r) {
+        (times_called += 1).must_equal 1
+        done!
+      })
+
+      sleep 0.050
+      d.reject(dummy)
+      d.reject(dummy)
+    end
+
+    it "trying to reject a pending promise more than once, immediately then delayed" do
+      d = deferred
+      times_called = 0
+
+      d.promise.then(nil, ->(r) {
+        (times_called += 1).must_equal 1
+        done!
+      })
+
+      d.reject(dummy)
+
+      sleep 0.050
+      d.reject(dummy)
+    end
+
+    it "when multiple `then` calls are made, spaced apart in time" do
+      d = deferred
+      times_called = [0, 0, 0]
+
+      d.promise.then(nil, ->(r) {
+        (times_called[0] += 1).must_equal 1
+      })
+
+      sleep 0.050
+      d.promise.then(nil, ->(r) {
+        (times_called[1] += 1).must_equal 1
+      })
+
+      sleep 0.050
+      d.promise.then(nil, ->(r) {
+        (times_called[2] += 1).must_equal 1
+        done!
+      })
+
+      sleep 0.050
+      d.reject(dummy)
+    end
+
+    it "when `then` is interleaved with rejection" do
+      d = deferred
+
+      times_called = [0, 0]
+
+      d.promise.then(nil, ->(r) {
+        (times_called[0] += 1).must_equal 1
+      })
+
+      d.reject(dummy)
+
+      d.promise.then(nil, ->(r) {
+        (times_called[1] += 1).must_equal 1
+        done!
+      })
+    end
+  end
+end

data/spec/promises_aplus/2_2_4_spec.rb

@@ -0,0 +1,188 @@
+# encoding: UTF-8
+require_relative "../spec_helper"
+require_relative "../promises_aplus"
+
+dummy = { dummy: "dummy" }
+sentinel = { sentinel: "sentinel" }
+
+describe "2.2.4: `onFulfilled` or `onRejected` must not be called until the execution context stack contains only platform code." do
+  include PromisesAplus
+
+  describe "`then` returns before the promise becomes fulfilled or rejected" do
+    before { done! and skip "don't know how to delay execution yet" }
+
+    PromisesAplus.test_fulfilled(self, sentinel) do |promise, done|
+      thenHasReturned = false
+
+      promise.then ->(v) {
+        thenHasReturned.must_equal true
+        done.call
+      }
+
+      thenHasReturned = true
+    end
+
+    PromisesAplus.test_rejected(self, dummy) do |promise, done|
+      thenHasReturned = false
+
+      promise.then nil, ->(r) {
+        thenHasReturned.must_equal true
+        done.call
+      }
+
+      thenHasReturned = true
+    end
+  end
+
+  describe "Clean-stack execution ordering tests (fulfillment case)" do
+    before { done! and skip "don't know how to delay execution yet" }
+
+    it "when `onFulfilled` is added immediately before the promise is fulfilled" do
+      d = deferred()
+      onFulfilledCalled = false
+
+      d.promise.then ->(v) do
+        onFulfilledCalled = true
+      end
+
+      d.resolve(dummy)
+
+      onFulfilledCalled.must_equal false
+      done!
+    end
+
+    it "when `onFulfilled` is added immediately after the promise is fulfilled" do
+      d = deferred()
+      onFulfilledCalled = false
+
+      d.resolve(dummy)
+
+      d.promise.then ->(v) do
+        onFulfilledCalled = true
+      end
+
+      onFulfilledCalled.must_equal false
+      done!
+    end
+
+    it "when one `onFulfilled` is added inside another `onFulfilled`" do
+      promise = resolved()
+      firstOnFulfilledFinished = false
+
+      promise.then ->(v) do
+        promise.then ->(v) do
+          firstOnFulfilledFinished.must_equal true
+          done!
+        end
+        firstOnFulfilledFinished = true
+      end
+    end
+
+    it "when `onFulfilled` is added inside an `onRejected`" do
+      promise = rejected()
+      promise2 = resolved()
+      firstOnRejectedFinished = false
+
+      promise.then nil, ->(r) do
+        promise2.then ->(v) do
+          firstOnRejectedFinished.must_equal true
+          done!
+        end
+        firstOnRejectedFinished = true
+      end
+    end
+
+    it "when the promise is fulfilled asynchronously" do
+      d = deferred()
+      firstStackFinished = false
+
+      f = Fiber.new do
+        d.resolve(dummy)
+        firstStackFinished = true
+      end
+
+      d.promise.then ->(v) do
+        firstStackFinished.must_equal true
+        done!
+      end
+
+      f.resume
+    end
+  end
+
+  describe "Clean-stack execution ordering tests (rejection case)" do
+    before { done! and skip "don't know how to delay execution yet" }
+
+    it "when `onRejected` is added immediately before the promise is rejected" do
+      d = deferred()
+      onRejectedCalled = false
+
+      d.promise.then nil, ->(r) do
+        onRejectedCalled = true
+      end
+
+      d.reject(dummy)
+
+      onRejectedCalled.must_equal false
+      done!
+    end
+
+    it "when `onRejected` is added immediately after the promise is rejected" do
+      d = deferred()
+      onRejectedCalled = false
+
+      d.reject(dummy)
+
+      d.promise.then nil, ->(r) do
+        onRejectedCalled = true
+      end
+
+      onRejectedCalled.must_equal false
+      done!
+    end
+
+    it "when `onRejected` is added inside an `onFulfilled`" do
+      promise = resolved()
+      promise2 = rejected()
+      firstOnFulfilledFinished = false
+
+      promise.then ->(v) do
+        promise2.then nil, ->(r) do
+          firstOnFulfilledFinished.must_equal true
+          done!
+        end
+        firstOnFulfilledFinished = true
+      end
+    end
+
+    it "when one `onRejected` is added inside another `onRejected`" do
+      promise = rejected()
+      firstOnRejectedFinished = false
+
+      promise.then nil, ->(r) do
+        promise.then nil, ->(r) do
+          firstOnRejectedFinished.must_equal true
+          done!
+        end
+        firstOnRejectedFinished = true
+      end
+    end
+
+    it "when the promise is rejected asynchronously" do
+      d = deferred()
+      firstStackFinished = false
+
+      f = Fiber.new do
+        d.reject(dummy)
+        firstStackFinished = true
+      end
+
+      d.promise.then nil, ->(r) do
+        firstStackFinished.must_equal true
+        done!
+      end
+
+      f.resume
+    end
+  end
+end