Update tests;

tests/combineLatest.lua

@@ -26,7 +26,7 @@ describe('combineLatest', function()
     expect(onNext).to.equal({{3}, {4}, {7}})
   end)
 
-  it('should call onComplete once all sources complete', function()
+  it('should call onCompleted once all sources complete', function()
     local observableA = Rx.Subject.create()
     local observableB = Rx.Subject.create()
     local complete = spy()
@@ -37,9 +37,9 @@ describe('combineLatest', function()
     expect(#complete).to.equal(0)
     observableB:onNext(2)
     expect(#complete).to.equal(0)
-    observableB:onComplete()
+    observableB:onCompleted()
     expect(#complete).to.equal(0)
-    observableA:onComplete()
+    observableA:onCompleted()
     expect(#complete).to.equal(1)
   end)
 

tests/compact.lua

@@ -12,7 +12,7 @@ describe('compact', function()
       observer:onNext(false)
       observer:onNext('')
       observer:onNext(0)
-      observer:onComplete()
+      observer:onCompleted()
     end)
 
     expect(observable:compact()).to.produce(true, '', 0)

tests/concat.lua

@@ -7,17 +7,17 @@ describe('concat', function()
   it('waits until one observable completes before producing items from the next', function()
     local subjectA = Rx.Subject.create()
     local subjectB = Rx.Subject.create()
-    local onNext, onError, onComplete = observableSpy(Rx.Observable.concat(subjectA, subjectB))
+    local onNext, onError, onCompleted = observableSpy(Rx.Observable.concat(subjectA, subjectB))
     subjectA:onNext(1)
     subjectB:onNext(2)
     subjectA:onNext(3)
-    subjectA:onComplete()
+    subjectA:onCompleted()
     subjectB:onNext(4)
     subjectB:onNext(5)
-    subjectB:onComplete()
+    subjectB:onCompleted()
     expect(onNext).to.equal({{1}, {3}, {4}, {5}})
     expect(#onError).to.equal(0)
-    expect(#onComplete).to.equal(1)
+    expect(#onCompleted).to.equal(1)
   end)
 
   it('should error if any of the sources error', function()
@@ -28,11 +28,11 @@ describe('concat', function()
 
   it('should complete once the rightmost observable completes', function()
     local subject = Rx.Subject.create()
-    local onComplete = spy()
+    local onCompleted = spy()
     local observable = Rx.Observable.concat(Rx.Observable.fromRange(1, 5), Rx.Observable.fromRange(1, 5), subject)
-    observable:subscribe(nil, nil, onComplete)
-    expect(#onComplete).to.equal(0)
-    subject:onComplete()
-    expect(#onComplete).to.equal(1)
+    observable:subscribe(nil, nil, onCompleted)
+    expect(#onCompleted).to.equal(0)
+    subject:onCompleted()
+    expect(#onCompleted).to.equal(1)
   end)
 end)

tests/distinct.lua

@@ -12,10 +12,10 @@ describe('distinct', function()
 
   it('completes when its parent completes', function()
     local subject = Rx.Subject.create()
-    local onComplete = spy()
-    subject:distinct():subscribe(nil, nil, onComplete)
-    expect(#onComplete).to.equal(0)
-    subject:onComplete()
-    expect(#onComplete).to.equal(1)
+    local onCompleted = spy()
+    subject:distinct():subscribe(nil, nil, onCompleted)
+    expect(#onCompleted).to.equal(0)
+    subject:onCompleted()
+    expect(#onCompleted).to.equal(1)
   end)
 end)

tests/find.lua

@@ -16,7 +16,7 @@ describe('find', function()
     local observable = Rx.Observable.create(function(observer)
       observer:onNext(1, 2, 3)
       observer:onNext(4, 5, 6)
-      observer:onComplete()
+      observer:onCompleted()
     end)
 
     observable:find(predicate):subscribe()

tests/first.lua

@@ -6,7 +6,7 @@ describe('first', function()
   end)
 
   it('produces no elements if its parent produces no elements', function()
-    local observable = Rx.Observable.create(function(observer) return observer:onComplete() end):first()
+    local observable = Rx.Observable.create(function(observer) return observer:onCompleted() end):first()
     expect(observable).to.produce({})
   end)
 

tests/last.lua

@@ -6,7 +6,7 @@ describe('last', function()
   end)
 
   it('produces no elements if its parent produces no elements', function()
-    local observable = Rx.Observable.create(function(observer) return observer:onComplete() end):last()
+    local observable = Rx.Observable.create(function(observer) return observer:onCompleted() end):last()
     expect(observable).to.produce({})
   end)
 

tests/merge.lua

@@ -8,13 +8,13 @@ describe('merge', function()
     local observableA = Rx.Subject.create()
     local observableB = Rx.Subject.create()
     local merged = observableA:merge(observableB)
-    local onNext, onError, onComplete = observableSpy(merged)
+    local onNext, onError, onCompleted = observableSpy(merged)
     observableA:onNext('a')
     observableB:onNext('b')
     observableB:onNext('b')
     observableA:onNext('a')
-    observableA:onComplete()
-    observableB:onComplete()
+    observableA:onCompleted()
+    observableB:onCompleted()
     expect(onNext).to.equal({{'a'}, {'b'}, {'b'}, {'a'}})
   end)
 
@@ -29,9 +29,9 @@ describe('merge', function()
     expect(#complete).to.equal(0)
     observableB:onNext(2)
     expect(#complete).to.equal(0)
-    observableB:onComplete()
+    observableB:onCompleted()
     expect(#complete).to.equal(0)
-    observableA:onComplete()
+    observableA:onCompleted()
     expect(#complete).to.equal(1)
   end)
 end)

tests/observable.lua

@@ -28,27 +28,27 @@ describe('Observable', function()
       expect(observer).to.be.an(Rx.Observer)
       expect(observer._onNext).to.equal(a)
       expect(observer._onError).to.equal(b)
-      expect(observer._onComplete).to.equal(c)
+      expect(observer._onCompleted).to.equal(c)
     end)
   end)
 
   describe('empty', function()
     it('returns an Observable that does not produce any values', function()
       local observable = Rx.Observable.empty()
-      local onNext, onError, onComplete = observableSpy(observable)
+      local onNext, onError, onCompleted = observableSpy(observable)
       expect(#onNext).to.equal(0)
       expect(#onError).to.equal(0)
-      expect(#onComplete).to.equal(1)
+      expect(#onCompleted).to.equal(1)
     end)
   end)
 
   describe('never', function()
     it('returns an Observable that does not produce values or complete', function()
       local observable = Rx.Observable.never()
-      local onNext, onError, onComplete = observableSpy(observable)
+      local onNext, onError, onCompleted = observableSpy(observable)
       expect(#onNext).to.equal(0)
       expect(#onError).to.equal(0)
-      expect(#onComplete).to.equal(0)
+      expect(#onCompleted).to.equal(0)
     end)
   end)
 
@@ -152,7 +152,7 @@ describe('Observable', function()
 
       Rx.scheduler = Rx.CooperativeScheduler.create()
       local observable = Rx.Observable.fromCoroutine(coroutine, Rx.scheduler)
-      local onNext, onError, onComplete = observableSpy(observable)
+      local onNext, onError, onCompleted = observableSpy(observable)
       repeat Rx.scheduler:update()
       until Rx.scheduler:isEmpty()
       expect(onNext).to.equal({{1}, {2}, {3}})
@@ -167,7 +167,7 @@ describe('Observable', function()
 
       Rx.scheduler = Rx.CooperativeScheduler.create()
       local observable = Rx.Observable.fromCoroutine(coroutine, Rx.scheduler)
-      local onNext, onError, onComplete = observableSpy(observable)
+      local onNext, onError, onCompleted = observableSpy(observable)
       repeat Rx.scheduler:update()
       until Rx.scheduler:isEmpty()
       expect(onNext).to.equal({{1}, {2}, {3}})

tests/observer.lua

@@ -4,16 +4,16 @@ describe('Observer', function()
       expect(Rx.Observer.create()).to.be.an(Rx.Observer)
     end)
 
-    it('assigns onNext, onError, and onComplete', function()
+    it('assigns onNext, onError, and onCompleted', function()
       local function onNext() end
       local function onError() end
-      local function onComplete() end
+      local function onCompleted() end
 
-      local observer = Rx.Observer.create(onNext, onError, onComplete)
+      local observer = Rx.Observer.create(onNext, onError, onCompleted)
 
       expect(observer._onNext).to.equal(onNext)
       expect(observer._onError).to.equal(onError)
-      expect(observer._onComplete).to.equal(onComplete)
+      expect(observer._onCompleted).to.equal(onCompleted)
     end)
 
     it('initializes stopped to false', function()
@@ -68,24 +68,24 @@ describe('Observer', function()
     end)
   end)
 
-  describe('onComplete', function()
-    it('calls _onComplete with no arguments', function()
+  describe('onCompleted', function()
+    it('calls _onCompleted with no arguments', function()
       local observer = Rx.Observer.create()
-      local function run() observer:onComplete(1, 2, 3) end
-      expect(spy(observer, '_onComplete', run)).to.equal({{}})
+      local function run() observer:onCompleted(1, 2, 3) end
+      expect(spy(observer, '_onCompleted', run)).to.equal({{}})
     end)
 
     it('sets stopped to true', function()
       local observer = Rx.Observer.create()
-      observer:onComplete()
+      observer:onCompleted()
       expect(observer.stopped).to.equal(true)
     end)
 
-    it('does not call _onComplete if stopped is already true', function()
+    it('does not call _onCompleted if stopped is already true', function()
       local observer = Rx.Observer.create()
       observer.stopped = true
-      local function run() observer:onComplete() end
-      expect(#spy(observer, '_onComplete', run)).to.equal(0)
+      local function run() observer:onCompleted() end
+      expect(#spy(observer, '_onCompleted', run)).to.equal(0)
     end)
   end)
 end)

tests/runner.lua

@@ -9,9 +9,9 @@ observableSpy = function(observable)
   local observer = Rx.Observer.create(_, function() end, _)
   local onNext = spy(observer, '_onNext')
   local onError = spy(observer, '_onError')
-  local onComplete = spy(observer, '_onComplete')
+  local onCompleted = spy(observer, '_onCompleted')
   observable:subscribe(observer)
-  return onNext, onError, onComplete
+  return onNext, onError, onCompleted
 end
 
 lust.paths['produce'] = {
@@ -28,22 +28,22 @@ lust.paths['produce'] = {
       values = args[1]
     end
 
-    local onNext, onError, onComplete = observableSpy(observable)
+    local onNext, onError, onCompleted = observableSpy(observable)
     expect(observable).to.be.an(Rx.Observable)
     expect(onNext).to.equal(values)
     expect(#onError).to.equal(0)
-    expect(#onComplete).to.equal(1)
+    expect(#onCompleted).to.equal(1)
     return true
   end
 }
 
 lust.paths['nothing'] = {
   f = function(observable)
-    local onNext, onError, onComplete = observableSpy(observable)
+    local onNext, onError, onCompleted = observableSpy(observable)
     expect(observable).to.be.an(Rx.Observable)
     expect(#onNext).to.equal(0)
     expect(#onError).to.equal(0)
-    expect(#onComplete).to.equal(1)
+    expect(#onCompleted).to.equal(1)
     return true
   end
 }

tests/skip.lua

@@ -27,10 +27,10 @@ describe('skip', function()
 
   it('completes and does not fail if it skips over more values than were produced', function()
     local observable = Rx.Observable.fromValue(3):skip(5)
-    local onNext, onError, onComplete = observableSpy(observable)
+    local onNext, onError, onCompleted = observableSpy(observable)
     expect(#onNext).to.equal(0)
     expect(#onError).to.equal(0)
-    expect(#onComplete).to.equal(1)
+    expect(#onCompleted).to.equal(1)
   end)
 
   it('produces the elements it did not skip over', function()

tests/skipUntil.lua

@@ -15,10 +15,10 @@ describe('skipUntil', function()
   it('produces no values if the specified observable does not produce any values', function()
     local trigger = Rx.Observable.create(function() end)
     local observable = Rx.Observable.fromTable({2, 3, 4}):skipUntil(trigger)
-    local onNext, onError, onComplete = observableSpy(observable)
+    local onNext, onError, onCompleted = observableSpy(observable)
     expect(#onNext).to.equal(0)
     expect(#onError).to.equal(0)
-    expect(#onComplete).to.equal(0)
+    expect(#onCompleted).to.equal(0)
   end)
 
   it('produces values after the specified observable produces a value', function()
@@ -31,7 +31,7 @@ describe('skipUntil', function()
     trigger:onNext('a')
     subject:onNext('c')
     subject:onNext('d')
-    subject:onComplete()
+    subject:onCompleted()
     expect(onNext).to.equal({{'c'}, {'d'}})
   end)
 
@@ -42,7 +42,7 @@ describe('skipUntil', function()
     subject:onNext(1)
     subject:onNext(2)
     subject:onNext(3)
-    subject:onComplete()
+    subject:onCompleted()
     expect(onNext).to.equal({{1}, {2}, {3}})
   end)
 end)

tests/take.lua

@@ -27,9 +27,9 @@ describe('take', function()
 
   it('completes and does not fail if it takes more values than were produced', function()
     local observable = Rx.Observable.fromValue(3):take(5)
-    local onNext, onError, onComplete = observableSpy(observable)
+    local onNext, onError, onCompleted = observableSpy(observable)
     expect(onNext).to.equal({{3}})
     expect(#onError).to.equal(0)
-    expect(#onComplete).to.equal(1)
+    expect(#onCompleted).to.equal(1)
   end)
 end)

tests/takeUntil.lua

@@ -28,7 +28,7 @@ describe('takeUntil', function()
     trigger:onNext('a')
     subject:onNext('c')
     subject:onNext('d')
-    subject:onComplete()
+    subject:onCompleted()
     expect(onNext).to.equal({{'a'}, {'b'}})
   end)
 
@@ -39,7 +39,7 @@ describe('takeUntil', function()
     subject:onNext(1)
     subject:onNext(2)
     subject:onNext(3)
-    subject:onComplete()
+    subject:onCompleted()
     expect(onNext).to.equal({})
   end)
 end)

tests/tap.lua

@@ -8,7 +8,7 @@ describe('tap', function()
     local onNext = spy()
     local observable = Rx.Observable.create(function(observer)
       observer:onNext(1)
-      observer:onComplete()
+      observer:onCompleted()
     end):tap(onNext):subscribe()
     expect(onNext).to.equal({{1}})
   end)
@@ -21,11 +21,11 @@ describe('tap', function()
     expect(onError).to.equal({{'message'}})
   end)
 
-  it('runs the specified onComplete function', function()
-    local onComplete = spy()
+  it('runs the specified onCompleted function', function()
+    local onCompleted = spy()
     local observable = Rx.Observable.create(function(observer)
-      observer:onComplete()
-    end):tap(_, _, onComplete):subscribe()
-    expect(#onComplete).to.equal(1)
+      observer:onCompleted()
+    end):tap(_, _, onCompleted):subscribe()
+    expect(#onCompleted).to.equal(1)
   end)
 end)

tests/unwrap.lua

@@ -10,7 +10,7 @@ describe('unwrap', function()
       observer:onNext(1)
       observer:onNext(2, 3)
       observer:onNext(4, 5, 6)
-      observer:onComplete()
+      observer:onCompleted()
     end)
     expect(observable).to.produce({{1}, {2, 3}, {4, 5, 6}})
     expect(observable:unwrap()).to.produce(1, 2, 3, 4, 5, 6)

tests/with.lua

@@ -21,15 +21,15 @@ describe('with', function()
   it('should complete only when the first observable completes', function()
     local subjectA = Rx.Subject.create()
     local subjectB = Rx.Subject.create()
-    local onComplete = spy()
-    subjectA:with(subjectB):subscribe(Rx.Observer.create(_, _, onComplete))
+    local onCompleted = spy()
+    subjectA:with(subjectB):subscribe(Rx.Observer.create(_, _, onCompleted))
     subjectA:onNext('a')
     subjectB:onNext('b')
-    subjectB:onComplete()
-    expect(#onComplete).to.equal(0)
+    subjectB:onCompleted()
+    expect(#onCompleted).to.equal(0)
     subjectA:onNext('c')
     subjectA:onNext('d')
-    subjectA:onComplete()
-    expect(#onComplete).to.equal(1)
+    subjectA:onCompleted()
+    expect(#onCompleted).to.equal(1)
   end)
 end)

tests/wrap.lua

@@ -14,7 +14,7 @@ describe('wrap', function()
       observer:onNext(1)
       observer:onNext(2, 3)
       observer:onNext(4, 5, 6)
-      observer:onComplete()
+      observer:onCompleted()
     end)
     expect(observable).to.produce({{1}, {2, 3}, {4, 5, 6}})
     expect(observable:wrap(2)).to.produce({{1, 2}, {3, 4}, {5, 6}})