Invalid behavior of ThrottleTime operator

[kzaher]

RxJS version:
5.5.8
6.1.0
rxjs-compat 6.1.0

Code to reproduce:

This is RxJs behavior

5.5.8

const rx = require('rxjs');

const a = rx.Observable.timer(0, 700).throttleTime(1000, rx.Scheduler.async, { leading: true, trailing: true });
let lastDate = new Date();  
let d = a.subscribe(x => { 
    const now = new Date(); 
    console.log('\n' + x + ' ' + (now.getTime() - lastDate.getTime())); 
    lastDate = now; 
});

6.1.0

const rx = require('rxjs');
require('rxjs/operators');
require('rxjs-compat/add/operator/throttleTime');

const a = rx.timer(0, 700).throttleTime(1000, rx.Scheduler.async, { leading: true, trailing: true });
let lastDate = new Date();  
let d = a.subscribe(x => { 
    const now = new Date(); 
    console.log('\n' + x + ' ' + (now.getTime() - lastDate.getTime())); 
    lastDate = now; 
});

Expected behavior:

This is underscore:

const underscore = require('underscore');
const rx = require('rxjs');

let lastDate = new Date();  
d= rx.Observable.timer(0, 700).subscribe(underscore.throttle(x => { 
    const now = new Date(); 
    console.log('\n' + x + ' ' + (now.getTime() - lastDate.getTime())); 
    lastDate = now; 
}, 
1000, 
{ leading: true, trailing: true }))

11 1003
12 1002
/// missing 13, all intervals above 1 sec
14 1001

This is RxSwift behavior

var last = Date();
        _ = Observable<Int>.timer(0, period: 0.7, scheduler: MainScheduler.instance)
            .throttle(1.0, latest: true, scheduler: MainScheduler.instance)
            .subscribe({ next in
                let now = Date();
                print("\(next) \(now.timeIntervalSince(last))");
                last = now;
            })

next(11) 1.00001406669617
next(12) 1.00061988830566
// missing 13, all intervals above 1 sec
next(14) 1.00011909008026

Actual behavior:

11 1000
12 407 // <--- time interval less then 1 sec
13 1004 // <--- has 13
14 402

Additional information:

The operator throttleTime is not behaving as I would expect. If I set throttle interval to 1sec I should never receive elements under 1 sec.

[bbonnet]

I was able to reproduce this behavior and implement a failing marble test case that I think matches what you're seeing. I can use some help confirming that this is indeed the expected behavior:

const dueTime =  time('|');
const period  =  time('---|');
const throttle = time('-----|                  ');
const expected =      'a----b----c----d----e(f|)';

const source = timer(dueTime, period, rxTestScheduler).take(8).throttleTime(throttle, rxTestScheduler, { leading: true, trailing: true });
const values = { a: 0, b: 1, c: 3, d: 4, e: 6, f: 7};
expectObservable(source).toBe(expected, values);

Want to make sure this is correct before attempting to implement a fix.

[kzaher]

Hi @bbonnet ,

what does (f|) mean? I'm not sure that e and f should be that close.

[bbonnet]

f, the last value is emitted immediately upon completion.

So this means that the throttle timer would emit e and then complete happens right away and then f is emitted. That's why the end up being so close.

[sod]

Tried to fix that in #2749 but gave up getting it into rxjs and just use my own operator.