cakeinpanic

var webpackConfig = require('../webpack.config.js');
module.exports = function () {
        autoWatch: true,
        frameworks: ['jasmine'],
        preprocessors: {
            '../app/**/*.js': ['webpack'],
            '../app/**/scripts/**/*.js': ['coverage']
        },
        webpack: {
            resolve: webpackConfig.resolve,

cakeinpanic

@Component({
    selector: 'inner-component',
    template: '<div (click)="onClick()">{{someValue}}</div>'
})
export class InputComponent {
    @Input() someValue: string;
    @Output() onClick = new EventEmitter<any>();
}

@NgModule({

cakeinpanic

// method we are testing
class MyService {
    someMethod() {
        Observable.interval(1000)
            .subscribe(() => {
                this.logger.logObservable();
            });

        setInterval(() => {
            this.logger.logInterval();

cakeinpanic

it('someMethod would be ran with iterator each second', (done) => {
  myService.someMethod();
  
  setTimeout(() => {
            expect(logger.logObservable).toHaveBeenCalledTimes(2);
            expect(logger.logInterval).toHaveBeenCalledTimes(1);
            done();
        }, 2 * 1000);
});

cakeinpanic

class MyService {
    constructor(private customInterval = 1000) {
    }

    someMethod() {
        Observable.interval(this.customInterval)
            .subscribe(() => {
                this.logger.logObservable();
            });

cakeinpanic

it('someMethod would be ran with iterator each second', fakeAsync(() => {
    myService.someMethod();

    tick(2 * 1000);

    expect(logger.logObservable).toHaveBeenCalledTimes(2);
    expect(logger.logInterval).toHaveBeenCalledTimes(1);

    // tell jasmine we don't need to emulate async anymore in this case
    discardPeriodicTasks();

cakeinpanic

it('someMethod would be ran with iterator each second', () => {
    const clock = <any>sinon.useFakeTimers(0);
    myService.someMethod();

    clock.tick(2 * 1000);
    expect(logger.logObservable).toHaveBeenCalledTimes(2);
    expect(logger.logInterval).toHaveBeenCalledTimes(1);

    // tell sinon to restore global timers for other tests
    clock.restore();

cakeinpanic

// https://github.com/angular/angular/issues/10127#issuecomment-247873713

it('should run async test with successful delayed Observable', fakeAsync(() => {
    let actuallyDone = false;
    let currentTime = 0;

    spyOn(Scheduler.async, 'now').and.callFake(() => currentTime);

    let source = Observable.of(true).delay(10);
    source.subscribe(() => {

cakeinpanic

const DELAY = 1000;

Rx.Observable.of(1, 2, 3)
  .delay(DELAY)
  .subscribe((data) => console.log(data))

Rx.Observable.of(1, 2, 3)
  .flatMap((data) => Rx.Observable.interval(DELAY).first().map(() => data))
  .subscribe((data) => console.log(data))

cakeinpanic

class MyService {
    sayHello(name: string) {
        return 'Hello ' + name;
    }
}


class MyComponent {
    constructor(private myService) {
    }