Unit Testing CycleJs Component with Mocha

so-test.js

//TO RUN TEST:
// mocha --compilers js:babel-core/register FILE-LOCATION/so-test.js 

import Rx from 'rx';
import {Observable} from 'rx';

import chai from 'chai';
const expect = chai.expect;

import CycleDOM from '@cycle/dom';
const {mockDOMSource} = CycleDOM;


Rx.config.longStackSupport = true;

const Model = ({test$, completeTask$, sources}) => {
    const processId = Number(sources.routeParams.processId);

    const SET_TEST_RESULTS = `http://dummyhost/tosettests/${processId}`;
    const GET_USER_TASKS = 'http://dummyhost/togetusertasks';

    const taskRequest$ = Observable.just({
        url: GET_USER_TASKS,
        method: 'GET'
    });

    const url$ = sources.HTTP
        .filter(response => response.request.url === GET_USER_TASKS)
        .flatMap(response => response.body)
        .filter(task => task.processId === processId)
        .take(1)
        .map(task=> {
            const activitiId = task.processInstanceId;
            return {
                completeTask: `http://dummyhost/tocompletetask/${activitiId}`
            };
        });

    const definedTest$ = test$
        .scan((acc, curr) => {
            acc.push(curr);
            return acc;
        }, [])
        .startWith([])
        .share();

    const setTestResultsRequest$ = completeTask$
        .withLatestFrom(definedTest$, (event, tests) => {
            return {
                url: SET_TEST_RESULTS,
                method: 'POST',
                send: {
                    tests
                }
            };
        });

    const setTestResultsResponse$ = sources.HTTP
        .filter(response => response.request.url === SET_TEST_RESULTS);

    const completeTaskRequest$ = setTestResultsResponse$
        .withLatestFrom(url$, (response, url) => {
            return {
                url: url.completeTask,
                method: 'POST'
            };
        });

    const completeTaskResponse$ = sources.HTTP
        .withLatestFrom(url$, (response, url) => {
            return {
                response,
                url
            };
        })
        .filter(data => data.response.request.url === data.url.completeTask)
        .map((data)=> data.response);

    const successNotification$ = completeTaskResponse$
        .map(() => {
            return {
                action: 'success',
                message: 'Tests have been defined!'
            };
        });


    const request$ = Observable.merge(taskRequest$, setTestResultsRequest$, completeTaskRequest$);

    return {
        request$: request$,
        notification$: successNotification$,
        definedTest$: definedTest$
    };
};

describe('When complete task is clicked', ()=> {
    const tests = [
        {
            name: 'test 1 name'
        },
        {
            name: 'test 2 name'
        },
        {
            name: 'test 3 name'
        }
    ];
    const test$ = Observable.fromArray(tests);
    const completeTask$ = Observable.just({}).delay(300);
    const processId = 3;
    const activitiId = 3;
    var actions;

    before(done => {
        const HTTPSource = new Rx.ReplaySubject();
        const sources = {
            DOM: mockDOMSource(),
            routeParams: {processId},
            HTTP: HTTPSource
        };

        actions = Model({test$, completeTask$, sources});
        const request$ = actions.request$.share();

        request$
            .filter(request=> request.url === 'http://dummyhost/togetusertasks')
            .subscribe((request) => {
                const response = {
                    request,
                    body: [{
                        processId,
                        processInstanceId: activitiId
                    }]
                };
                HTTPSource.onNext(response);
            });

        request$
            .filter(request=> request.url === `http://dummyhost/tosettests/${processId}`)
            .subscribe((request) => {
                const response = {
                    request
                };

                HTTPSource.onNext(response);
            });

        request$
            .filter(request=> request.url === `http://dummyhost/tocompletetask/${activitiId}`)
            .subscribe((request) => {
                const response = {
                    request
                };

                HTTPSource.onNext(response);
                done();
            });


    });

    it('should send a request to add tests', (done)=> {
        actions.request$
            .filter(request=> request.url === `http://dummyhost/tosettests/${processId}`)
            .subscribe(() => {
                done();
            });
    });

    it('should send a request to complete task', (done)=> {
        actions.request$
            .filter(request=> request.url === `http://dummyhost/tocompletetask/${activitiId}`)
            .subscribe(() => {
                done();
            });
    });

    it('should show a notification to inform user that tests have been defined', (done) => {
        actions.notification$.take(1)
            .subscribe(notification => {
                expect(notification.action).to.equal('success');
                done();
            });
    });
});