Improve test coverage;

tests/average.lua

@@ -1,6 +1,7 @@
 describe('average', function()
   it('errors when its parent errors', function()
-    expect(Rx.Observable.throw():average().subscribe).to.fail()
+    local _, onError = observableSpy(Rx.Observable.throw():average())
+    expect(#onError).to.equal(1)
   end)
 
   it('produces a single value representing the average of the values produced by the source', function()

tests/buffer.lua

@@ -1,8 +1,7 @@
 describe('buffer', function()
   it('produces an error if its parent errors', function()
-    local observable = Rx.Observable.of(''):map(function(x) return x() end)
-    expect(observable.subscribe).to.fail()
-    expect(observable:buffer().subscribe).to.fail()
+    local _, onError = observableSpy(Rx.Observable.throw():buffer())
+    expect(#onError).to.equal(1)
   end)
 
   it('fails if size is not specified', function()
@@ -24,4 +23,16 @@ describe('buffer', function()
     local observable = Rx.Observable.fromRange(5)
     expect(observable:buffer(2)).to.produce({{1, 2}, {3, 4}, {5}})
   end)
+
+  it('produces a partial buffer if the observable errors', function()
+    local observable = Rx.Observable.create(function(observer)
+      observer:onNext(1)
+      observer:onNext(2)
+      observer:onNext(3)
+      observer:onError('oops')
+    end)
+    local onNext, onError = observableSpy(observable:buffer(2))
+    expect(onNext).to.equal({{1, 2}, {3}})
+    expect(#onError).to.equal(1)
+  end)
 end)

tests/catch.lua

@@ -35,4 +35,10 @@ describe('catch', function()
     Rx.Observable.throw():catch(handler):subscribe(nil, onError, nil)
     expect(#onError).to.equal(1)
   end)
+
+  it('calls onComplete when the parent completes', function()
+    local onComplete = spy()
+    Rx.Observable.throw():catch():subscribe(nil, nil, onComplete)
+    expect(#onComplete).to.equal(1)
+  end)
 end)

tests/concat.lua

@@ -1,4 +1,9 @@
 describe('concat', function()
+  it('produces an error if its parent errors', function()
+    local _, onError = observableSpy(Rx.Observable.throw():concat())
+    expect(#onError).to.equal(1)
+  end)
+
   it('returns the first argument if it is the only argument', function()
     local observable = Rx.Observable.fromRange(1, 3):concat()
     expect(observable).to.produce(1, 2, 3)

tests/contains.lua

@@ -1,6 +1,7 @@
 describe('contains', function()
   it('errors when its parent errors', function()
-    expect(Rx.Observable.throw():contains(1).subscribe).to.fail()
+    local _, onError = observableSpy(Rx.Observable.throw():contains(1))
+    expect(#onError).to.equal(1)
   end)
 
   it('returns false if the source Observable produces no values', function()

tests/count.lua

@@ -1,8 +1,7 @@
 describe('count', function()
   it('passes through errors', function()
-    local observable = Rx.Observable.create(function(observer) observer:onError() end)
-    expect(observable.subscribe).to.fail()
-    expect(observable:count().subscribe).to.fail()
+    local _, onError = observableSpy(Rx.Observable.throw():count())
+    expect(#onError).to.equal(1)
   end)
 
   it('produces a single value representing the number of elements produced by the source', function()

tests/defaultIfEmpty.lua

@@ -1,6 +1,7 @@
 describe('defaultIfEmpty', function()
   it('errors if the source errors', function()
-    expect(Rx.Observable.throw():defaultIfEmpty(1).subscribe).to.fail()
+    local _, onError = observableSpy(Rx.Observable.throw():defaultIfEmpty(1))
+    expect(#onError).to.equal(1)
   end)
 
   it('produces the values from the source unchanged if at least one value is produced', function()

tests/distinct.lua

@@ -5,9 +5,8 @@ describe('distinct', function()
   end)
 
   it('produces an error if its parent errors', function()
-    local observable = Rx.Observable.of(''):map(function(x) return x() end)
-    expect(observable.subscribe).to.fail()
-    expect(observable:distinct().subscribe).to.fail()
+    local _, onError = observableSpy(Rx.Observable.throw():distinct())
+    expect(#onError).to.equal(1)
   end)
 
   it('completes when its parent completes', function()

tests/distinctUntilChanged.lua

@@ -1,8 +1,7 @@
 describe('distinctUntilChanged', function()
   it('produces an error if its parent errors', function()
-    local observable = Rx.Observable.of(''):map(function(x) return x() end)
-    expect(observable.subscribe).to.fail()
-    expect(observable:distinctUntilChanged().subscribe).to.fail()
+    local _, onError = observableSpy(Rx.Observable.throw():distinctUntilChanged())
+    expect(#onError).to.equal(1)
   end)
 
   describe('with the default comparator', function()

tests/elementAt.lua

@@ -1,6 +1,7 @@
 describe('elementAt', function()
   it('errors when its parent errors', function()
-    expect(Rx.Observable.throw():elementAt(1).subscribe).to.fail()
+    local _, onError = observableSpy(Rx.Observable:throw():elementAt(0))
+    expect(#onError).to.equal(1)
   end)
 
   it('chains subscriptions', function()
@@ -10,6 +11,16 @@ describe('elementAt', function()
     expect(observable:elementAt(1):subscribe()).to.equal(subscription)
   end)
 
+  it('unsubscribes the subscription if the element is produced', function()
+    local subject = Rx.Subject.create()
+    local subscription = subject:elementAt(2):subscribe()
+    subscription.unsubscribe = spy()
+    subject:onNext('a')
+    expect(#subscription.unsubscribe).to.equal(0)
+    subject:onNext('b')
+    expect(#subscription.unsubscribe).to.equal(1)
+  end)
+
   it('errors if no index is specified', function()
     expect(Rx.Observable.of(1):elementAt().subscribe).to.fail()
   end)

tests/filter.lua

@@ -17,9 +17,8 @@ describe('filter', function()
   end)
 
   it('errors when its parent errors', function()
-    local observable = Rx.Observable.of(''):map(function(x) return x() end)
-    expect(observable.subscribe).to.fail()
-    expect(observable:filter().subscribe).to.fail()
+    local _, onError = observableSpy(Rx.Observable.throw():filter())
+    expect(#onError).to.equal(1)
   end)
 
   it('calls onError if the predicate errors', function()