application/__tests__/hocs/draftable-test.js

jest.unmock('./../../hocs/draftable');
jest.unmock('./../../services/base-service');
jest.unmock('./../../services/error-service');
jest.unmock('./../../services/draft-service');
 
jest.unmock('./../../util/strings');
jest.unmock('./../../alt');
 
import React from 'react';
import ReactDOM from 'react-dom';
import TestUtils from 'react-addons-test-utils';
import Immutable from 'immutable';
import sinon from 'sinon';
import AltTestingUtils from 'alt-utils/lib/AltTestingUtils';
import {Input} from 'react-materialize';
 
import fetch from './../../util/mock-fetch';
 
import {DraftService, DraftsStore} from './../../services/draft-service';
import {withDraftable} from './../../hocs/draftable';
 
class MockChild extends React.Component {
    constructor(props) {
        super(props);
    }
 
    draftCb() {
        return;
    }
 
    updateCb() {
        return;
    }
 
    componentWillMount() {
        this.props.draftable.doesHaveDraft({'srn': 'tsn:123'}, this.draftCb);
        this.props.draftable.setDraftCreatedHook(this.updateCb);
    }
 
    componentWillUnmount() {
 
    }
 
    render() {
        return (
            <div className='internalObject'></div>
        );
    }
}
const MockWrapped = withDraftable(MockChild);
 
describe('DraftableComponent', () => {
 
    beforeEach(() => {
        jasmine.clock().uninstall();
        jasmine.clock().install();
        sinon.stub(window, 'fetch').returns(fetch([
            {
                id: 1,
                srn: 'srn:tsn:ceo-core:content/5432543-54325432',
                uuid: '5432543-54325432',
                slug: 'imma-test-slug',
                created_at: '2016-05-09 15:23:01',
                modified_at: '2016-05-09 15:34:16',
                published_at: null,
                version: 5
            }
        ]));
 
        sinon.stub(MockChild.prototype, 'componentWillMount');
    });
 
    afterEach(() => {
        window.fetch.restore();
        jasmine.clock().uninstall();
        MockChild.prototype.componentWillMount.restore();
    });
 
    it('wraps component', () => {
        const wrapSpy = sinon.spy(MockWrapped.prototype, 'componentWillMount');
 
        const el = TestUtils.renderIntoDocument(<MockWrapped />);
        expect(wrapSpy.called).toEqual(true);
        expect(el.interval).not.toEqual(false);
        MockWrapped.prototype.componentWillMount.restore();
    });
 
    it('calls interval', () => {
        const wrapSpy = sinon.spy(MockWrapped.prototype, 'createDraft');
 
        const el = TestUtils.renderIntoDocument(<MockWrapped />);
 
        expect(wrapSpy.called).toEqual(false);
        expect(el.isDirty).toEqual(false);
 
        jasmine.clock().tick(5001);
 
        expect(wrapSpy.called).toEqual(true);
        expect(el.isDirty).toEqual(false);
 
        MockWrapped.prototype.createDraft.restore();
    });
 
    it('is dirty', (done) => {
        const wrapSpy = sinon.spy(MockWrapped.prototype, 'createDraft');
 
        const el = TestUtils.renderIntoDocument(<MockWrapped />);
 
        el.setState({'raw': {}});
 
        expect(wrapSpy.called).toEqual(false);
        expect(el.isDirty).toEqual(false);
        expect(JSON.stringify(el.state.raw)).toEqual('{}');
 
        el.onChange({'raw': {'foo': 'bar'}});
        expect(JSON.stringify(el.state.raw)).toEqual('{"foo":"bar"}');
        expect(el.isDirty).toEqual(true);
 
        jasmine.clock().tick(5001);
        expect(wrapSpy.called).toEqual(true);
 
        jasmine.clock().tick(101);
        expect(window.fetch.called).toEqual(true);
 
        // actually wait for the return
        jasmine.clock().uninstall();
        setTimeout(() => {
            expect(el.isDirty).toEqual(false);
 
            MockWrapped.prototype.createDraft.restore();
            done()
        }, 100);
    });
 
    it('is not dirty', () => {
        const wrapSpy = sinon.spy(MockWrapped.prototype, 'createDraft');
 
        const el = TestUtils.renderIntoDocument(<MockWrapped />);
 
        el.setState({'raw': {'foo': 'bar'}});
 
        expect(wrapSpy.called).toEqual(false);
        expect(el.isDirty).toEqual(false);
 
        el.onChange({'raw': {'foo': 'bar'}});
        expect(el.isDirty).toEqual(false);
 
        jasmine.clock().tick(5001);
        expect(wrapSpy.called).toEqual(true);
 
        jasmine.clock().tick(101);
        expect(el.isDirty).toEqual(false);
        expect(window.fetch.called).toEqual(false);
 
        MockWrapped.prototype.createDraft.restore();
    });
 
    it('returns valid draft', (done) => {
        window.fetch.restore();
        MockChild.prototype.componentWillMount.restore();
 
        sinon.stub(window, 'fetch').returns(fetch([
            {
                id: 1,
                content_raw: '{"foo":"bar"}'
            }
        ]));
 
        const mockSpy = sinon.spy(MockChild.prototype, 'draftCb');
        const checkSpy = sinon.spy(MockWrapped.prototype, 'checkDraft');
 
        jasmine.clock().uninstall();
        const el = TestUtils.renderIntoDocument(<MockWrapped />);
 
        setTimeout(() => {
            expect(checkSpy.called).toEqual(true);
            expect(window.fetch.called).toEqual(true);
            expect(mockSpy.called).toEqual(true);
 
            const ret = mockSpy.getCalls()[0].args[0];
            expect(ret.get('content_raw')).toEqual('{"foo":"bar"}');
 
            MockChild.prototype.draftCb.restore();
            MockWrapped.prototype.checkDraft.restore();
 
            sinon.stub(MockChild.prototype, 'componentWillMount');
            done();
        }, 100);
    });
 
    it('returns empty draft', (done) => {
        window.fetch.restore();
        MockChild.prototype.componentWillMount.restore();
 
        sinon.stub(window, 'fetch').returns(fetch([]));
 
        const mockSpy = sinon.spy(MockChild.prototype, 'draftCb');
        const checkSpy = sinon.spy(MockWrapped.prototype, 'checkDraft');
 
        jasmine.clock().uninstall();
        const el = TestUtils.renderIntoDocument(<MockWrapped />);
 
        setTimeout(() => {
            expect(checkSpy.called).toEqual(true);
            expect(window.fetch.called).toEqual(true);
            expect(mockSpy.called).toEqual(true);
 
            const ret = mockSpy.getCalls()[0].args[0];
            expect(ret).toEqual(false);
 
            MockChild.prototype.draftCb.restore();
            MockWrapped.prototype.checkDraft.restore();
 
            sinon.stub(MockChild.prototype, 'componentWillMount');
            done();
        }, 100);
    });
 
    it('returns calls update callback', (done) => {
        window.fetch.restore();
        MockChild.prototype.componentWillMount.restore();
 
        sinon.stub(window, 'fetch').returns(fetch([
            {
                id: 1,
                content_raw: '{"foo":"bar"}'
            }
        ]));
 
        const mockSpy = sinon.spy(MockChild.prototype, 'updateCb');
 
        const el = TestUtils.renderIntoDocument(<MockWrapped />);
        expect(mockSpy.called).toEqual(false);
 
        el.onChange({'raw': {'foo': 'bar'}});
 
        jasmine.clock().tick(5101);
 
        // actually wait for the return
        jasmine.clock().uninstall();
        setTimeout(() => {
            expect(mockSpy.called).toEqual(true);
 
            MockChild.prototype.updateCb.restore();
 
            sinon.stub(MockChild.prototype, 'componentWillMount');
            done();
        }, 100);
    });
 
});